Introdução a Conjuntos (Manual do Maxima)

Próximo: Funções e Variáveis Definidas 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ícitamente. Maxima trata listas e conjuntos como objetos distintos. Esse 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 funoes relacionadas a análise combinatória; essas incluem os números de Stirling de primero e de segundo tipo, os números de Bell, coefincientes multinomiais, partições de inteiros não negativos, e umas poucas outras. Maxima também define uma 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. Conjuntos são sempre mostrados entre chaves (`{ ... }`).

Se um elemento é listado mais de uma vez, a simplificação 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 (i.e., 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 conjuntos `x` e `y` são iguais fornecendo `is(x = y)` avaliando para `true`. Dessa forma `rat(x)` e `x` são iguais como elementos de conjuntos; conseqüentemente,

    (%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 distintos elementos de conjunto; 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 elemeto 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 de outros conjuntos, você pode precisar 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 esta’simplificado quando seus elementos não são redundantes e o conjunto está ordenado. A versão corrente das funções de conjunto usam a função do Máxima `orderlessp` para ordenar conjuntos; odavia, versões futuras das funções de conjunto podem 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 objetos distintos; funções tais como `union` e `intersection` reclamam se qualquer argumetno não for um conjunto. se você precisar aplicar uma função de conjunto a uma lista, use a função `setify` para converter essa lsita para um 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 elemetnos de conjunto 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 em um 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 seção Funções e Variáveis Definidas para Conjuntos passui uma lista completa das funções de conjunto no Maxima.

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

Existem dois camainhos para fazer iterações sobre elementos de conjuntos. Um caminho é usar `map`; por exemplo:

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

O outro caminho é 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

A função Maxima `first` e `rest` trabalham atualmente sobre conjuntos. Aplicada a um conjunto, `first` retorna o primeiro elemento mostrado de um conjunto; qual élemento que é mostrado pode ser dependente da implementação. Se `s` for um conjunto, então `rest(s)` é equivalente a `disjoin(first(s), s)`. Atualmente, existem outras funções do Maxima que trabalham corretamente sobre conjuntos. Em futuras versões das funções de conjunto, `first` e `rest` podem vir a funcionar diferentemente ou não completamente.

#### 38.1.3, Erros

As funções de conjunto usam a função Maxima `orderlessp` para organizar os elementos de cum conjunto e a função (a nível de Lisp) `like` para testar a igualdade entre elementos de conjuntos. Ambas essas funções possuem falhas conhecidas que podem se manifestar se você 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 fique exitante com um erro (a mensagem de erro depende de qual a versão do Lisp seu Maxima está usando). 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`; elas não são caudadas por falhas nas funções de conjunto. Para ilustrar, tente 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 sejam corrigidas, não construa conjuntos com com elementos que sejam listas ou matrizes contendo expressões na forma racional canônica (CRE); um conjunto com um elemento na forma CRE, todavia, pode não ser um problema:

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

A `orderlessp` do Maxima possui outra falha que pode causr problemas com funções de conjunto, sabidamente 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 conjutno bem como com funções 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 simplificado usando `ratsimp`.

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

Se você encontrar alguma coisa que você pense ser uma falha em alguma função 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 e Nebraska e Kearney (UNK) escreveram as fnções de conjunto do Maxima e sua documentação.

Próximo: Funções e Variáveis Definidas para Conjuntos, Anterior: Conjuntos, Acima: Conjuntos [Conteúdo][Índice]