Introdução a Conjuntos (Manual do Maxima 5.44.0)

Próximo: Definições para Conjuntos, Anterior: Conjuntos, Acima: Conjuntos [Conteúdo][Índice]

### 38.1, Introdução a Conjuntos

Maxima fornece funções de conjunto, tais como intersecção e união, para conjuntos finitos que são definidos por enumeração explícita. Maxima trata listas e conjuntos como objectos distintos. Este recurso torna possível trabalhar com conjuntos que possuem elementos que são ou listas ou conjuntos.

Adicionalmente, para funções de conjuntos finitos, Maxima fornece algumas funções relacionadas com análise combinatória: números de Stirling de primeiro e de segundo tipo, números de Bell, coeficientes multinomiais e partições de inteiros não negativos, entre outras. Maxima também define a função delta de Kronecker.

#### 38.1.1, Utilização

Para construir um conjunto com elementos `a_1, ..., a_n`, escreva `set(a_1, ..., a_n)` ou `{a_1, ..., a_n}`; para construir o conjunto vazio, escreva `set()` ou `{}`. Para inserção de dados, `set(...)` e `{ ... }` são equivalentes. Os conjuntos são sempre mostrados entre chaves (`{ ... }`).

Se um elemento é listado mais de uma vez, o simplificador do Maxima elimina o elemento redundante.

    (%i1) set();
    (%o1)                          {}
    (%i2) set(a, b, a);
    (%o2)                        {a, b}
    (%i3) set(a, set(b));
    (%o3)                       {a, {b}}
    (%i4) set(a, [b]);
    (%o4)                       {a, [b]}
    (%i5) {};
    (%o5)                          {}
    (%i6) {a, b, a};
    (%o6)                        {a, b}
    (%i7) {a, {b}};
    (%o7)                       {a, {b}}
    (%i8) {a, [b]};
    (%o8)                       {a, [b]}

Dois elementos x e y são redundantes (nomeadamente, considerados o mesmo para propósito de construção de conjuntos) se e somente se `is(x = y)` retornar `true`. Note que `is(equal(x, y))` pode retornar `true` enquanto `is(x = y)` retorna `false`; nesse caso os elementos x e y são considerados distintos.

    (%i1) x: a/c + b/c;
                                  b   a
    (%o1)                         - + -
                                  c   c
    (%i2) y: a/c + b/c;
                                  b   a
    (%o2)                         - + -
                                  c   c
    (%i3) z: (a + b)/c;
                                  b + a
    (%o3)                         -----
                                    c
    (%i4) is (x = y);
    (%o4)                         true
    (%i5) is (y = z);
    (%o5)                         false
    (%i6) is (equal (y, z));
    (%o6)                         true
    (%i7) y - z;
                               b + a   b   a
    (%o7)                    - ----- + - + -
                                 c     c   c
    (%i8) ratsimp (%);
    (%o8)                           0
    (%i9) {x, y, z};
                              b + a  b   a
    (%o9)                    {-----, - + -}
                                c    c   c

Para construir um conjunto dos elementos de uma lista, use `setify`.

    (%i1) setify ([b, a]);
    (%o1)                        {a, b}

Os elementos de conjunto `x` e `y` serão considerados iguais se `is(x = y)` for avaliando para `true`. Dessa forma, `rat(x)` e `x` são iguais como elementos de conjunto; consequentemente,

    (%i1) {x, rat(x)};
    (%o1)                          {x}

Adicionalmente, uma vez que `is((x - 1)*(x + 1) = x^2 - 1)` avalia para `false`, `(x - 1)*(x + 1)` e `x^2 - 1` são considerados elementos de conjunto diferentes; dessa forma

    (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                           2
    (%o1)               {(x - 1) (x + 1), x  - 1}

Para reduzir esse conjunto a um conjunto simples, apliquemos `rat` a cada elemento do conjunto

    (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                           2
    (%o1)               {(x - 1) (x + 1), x  - 1}
    (%i2) map (rat, %);
                                  2
    (%o2)/R/                    {x  - 1}

Para remover redundâncias em outros conjuntos, poderá ter que usar outras funções de simplificação. Aqui está um exemplo que usa `trigsimp`:

    (%i1) {1, cos(x)^2 + sin(x)^2};
                                2         2
    (%o1)                {1, sin (x) + cos (x)}
    (%i2) map (trigsimp, %);
    (%o2)                          {1}

Um conjunto está simplificado quando os seus elementos não são redundantes e o conjunto está ordenado. A versão actual das funções de conjunto usam a função `orderlessp` do Maxima para ordenar conjuntos; contudo, versões futuras das funções de conjunto poderão vir a usar uma função de ordenação diferente.

Algumas operações sobre conjuntos, tais como substituições, forçam automaticamente a uma re-simplificação; por exemplo,

    (%i1) s: {a, b, c}$
    (%i2) subst (c=a, s);
    (%o2)                        {a, b}
    (%i3) subst ([a=x, b=x, c=x], s);
    (%o3)                          {x}
    (%i4) map (lambda ([x], x^2), set (-1, 0, 1));
    (%o4)                        {0, 1}

Maxima trata listas e conjuntos como objectos distintos; funções tais como `union` e `intersection` produzem um erro se qualquer argumento não for um conjunto. se precisar aplicar uma função de conjunto a uma lista, use a função `setify` para converter essa lista num conjunto. Dessa forma

    (%i1) union ([1, 2], {a, b});
    Function union expects a set, instead found [1,2]
     -- an error.  Quitting.  To debug this try debugmode(true);
    (%i2) union (setify ([1, 2]), {a, b});
    (%o2)                     {1, 2, a, b}

Para extrair todos os elementos de um conjunto `s` que satisfazem um predicado `f`, use `subset(s, f)`. (Um predicado é um uma função que avalia para os valores booleanos `true`/`false`.) Por exemplo, para encontrar as equações num dado conjunto que não depende de uma variável `z`, use

    (%i1) subset ({x + y + z, x - y + 4, x + y - 5}, lambda ([e], freeof (z, e)));
    (%o1)               {- y + x + 4, y + x - 5}

A secção Definições para Conjuntos possui uma lista completa das funções de conjunto no Maxima.

#### 38.1.2, Iterações entre Elementos de Conjuntos

Existem duas formas de fazer iterações sobre elementos de conjuntos. Uma forma é usar `map`; por exemplo:

    (%i1) map (f, {a, b, c});
    (%o1)                  {f(a), f(b), f(c)}

A outra forma consiste em usar `for x in s do`

    (%i1) s: {a, b, c};
    (%o1)                       {a, b, c}
    (%i2) for si in s do print (concat (si, 1));
    a1
    b1
    c1
    (%o2)                         done

As funções `first` e `rest` do Maxima trabalham actualmente sobre conjuntos. Aplicada a um conjunto, `first` retorna o primeiro elemento mostrado de um conjunto; qual o élemento que será mostrado dependerá da implementação. Se `s` for um conjunto, então `rest(s)` é equivalente a `disjoin(first(s), s)`. Actualmente, existem outras funções do Maxima que trabalham correctamente sobre conjuntos. Em versões futuras das funções de conjunto, `first` e `rest` podem vir a funcionar diferentemente ou deixar de funcionar.

#### 38.1.3, Erros

As funções de conjunto usam a função `orderlessp` do Maxima para organizar os elementos dum conjunto e a função (a nível do Lisp) `like` para testar a igualdade entre elementos de conjuntos. Ambas essas funções possuem falhas conhecidas que podem se manifestar quando tentar usar conjuntos com elementos que são listas ou matrizes que contenham expressões na forma racional canónica (CRE). Um exemplo é

    (%i1) {[x], [rat (x)]};
    Maxima encountered a Lisp error:

      The value #:X1440 is not of type LIST.

    Automatically continuing.
    To reenable the Lisp debugger set *debugger-hook* to nil.

Essa expressão faz com que o Maxima produza um erro (a mensagem de erro dependerá da versão do Lisp que o Maxima estiver a utilizar). Outro exemplo é

    (%i1) setify ([[rat(a)], [rat(b)]]);
    Maxima encountered a Lisp error:

      The value #:A1440 is not of type LIST.

    Automatically continuing.
    To reenable the Lisp debugger set *debugger-hook* to nil.

Essas falhas são causadas por falhas em `orderlessp` e `like`, e não por falhas nas funções de conjunto. Para ilustrar, experimente as expressões

    (%i1) orderlessp ([rat(a)], [rat(b)]);
    Maxima encountered a Lisp error:

      The value #:B1441 is not of type LIST.

    Automatically continuing.
    To reenable the Lisp debugger set *debugger-hook* to nil.
    (%i2) is ([rat(a)] = [rat(a)]);
    (%o2)                         false

Até que essas falhas forem corrigidas, não construa conjuntos com elementos que sejam listas ou matrizes contendo expressões na forma racional canónica (CRE); um conjunto com um elemento na forma CRE, contudo, pode não ser um problema:

    (%i1) {x, rat (x)};
    (%o1)                          {x}

A `orderlessp` do Maxima possui outra falha que pode causar problemas com funções de conjunto; nomeadamente, o predicado de ordenação `orderlessp` não é transitivo. O mais simples exemplo conhecido que mostra isso é

    (%i1) q: x^2$
    (%i2) r: (x + 1)^2$
    (%i3) s: x*(x + 2)$
    (%i4) orderlessp (q, r);
    (%o4)                         true
    (%i5) orderlessp (r, s);
    (%o5)                         true
    (%i6) orderlessp (q, s);
    (%o6)                         false

Essa falha pode causar problemas com todas as funções de conjunto bem como com funções do Maxima em geral. É provável, mas não certo, que essa falha possa ser evitada se todos os elementos do conjunto estiverem ou na forma CRE ou tiverem sido simplificados usando `ratsimp`.

Os mecanismos `orderless` e `ordergreat` do Maxima são incompatíveis com as funções de conjunto. Se precisar usar `orderless` ou `ordergrreat`, chame todas essas funções antes de construir quaisquer conjuntos, e não use `unorder`.

Se encontrar alguma coisa que pense ser uma falha em alguma funçõ de conjunto, por favor relate isso para a base de dados de falhas do Maxima. Veja `bug_report`.

#### 38.1.4, Autores

Stavros Macrakis de Cambridge, Massachusetts e Barton Willis da Universidade de Nebraska e Kearney (UNK) escreveram as fnções de conjunto do Maxima e sua documentação.

Próximo: Definições para Conjuntos, Anterior: Conjuntos, Acima: Conjuntos [Conteúdo][Índice]