Práctica1 de Matemática Discreta: Conjuntos con SAGE

1. Listas  y conjuntos

Las listas en Sage pueden almacenar elementos de distintos tipos. Son objetos mutables (pueden modificarse añadiendo o
quitando elementos y modificando los ya existentes) y puede accederse a sus elementos directamente por posición.

Importante: los elementos comienzan a numerarse desde 0.

lista = ['a', 'b', 'c', 1, 2, 3]

lista[0] 
'a'

Un tipo particular de lista son los rangos. El comando range(ini, fin, s) crea una lista de números que empieza en ini y va con un
incremento de s unidades hasta el mayor número posible antes de fin (éste no lo incluye). Por ejemplo, los números del 0 al 100,
sin incluir este último, en incrementos de 5.

Nota: si no se indica el incremento se toma igual a 1 y si no se indica el inicio se considera que es 0.

range(0,104,5) 
[0,
5,
10,
15,
20,
25,
30,
35,
40,
45,
50,
55,
60,
65,
70,
75,
80,
85,
90,
95,
100]
range(10) 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Las listas se pueden crear por comprensión (dando las propiedades que definen a sus elementos), al igual que los conjuntos. Por
ejemplo, números primos p entre 1 y 10000 tales que p+2 es primo:

is_prime(46789543) 
True
is_prime(1) 
False
lista = [n for n in range(1,1000) if (is_prime(n) and is_prime(n+2))]
lista 
[3,
5,
11,
17,
29,
41,
59,
71,
101,
107,

1 de 9
 137,
149,
179,
191,
197,
227,
239,
269,
281,
311,
347,
419,
431,
461,
521,
569,
599,
617,
641,
659,
809,
821,
827,
857,
881]
lista[5] 
41

Sage tiene una función que identifica el tipo de número que tengamos, es decir, si es entero, racional o real.

type(1) 
<type 'sage.rings.integer.Integer'>
type(2/5) 
<type 'sage.rings.rational.Rational'>
type(3.5) 
<type 'sage.rings.real_mpfr.RealLiteral'>
type(4.) 
<type 'sage.rings.real_mpfr.RealLiteral'>

Podemos extraer sublistas de una lista dada. Por ejemplo: la sublista que comprende desde el sexto hasta el decimoquinto
elemento. Nota: el valor inicial y/o el final son opcionales.

lista = range(21)
lista[5:15] 
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
lista 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20]

Se pueden cambiar los elementos que forman una lista accediendo a ellos a través de su posición:

lista[20] = 768
lista 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 768]

Podemos obtener la longitud (dimensión) de una lista

len(lista) 
21

A las listas se les puede añadir elementos al final:

2 de 9
 lista.append('fin')
lista 
[0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
768,
'fin']
len(lista) 
22

O en cualquier posición:

lista.insert(6,'nuevo')
lista 
[0,
1,
2,
3,
4,
5,
'nuevo',
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
768,
'fin']

O quitárselos (por contenido o por índice):

lista.remove('fin')
lista 
[0,
1,
2,
3,
4,
5,
'nuevo',
6,
7,

3 de 9
 8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
768]
del lista[1]
lista 
[0,
2,
3,
4,
5,
'nuevo',
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
768]
del(lista[4],lista[7])
lista 
[0, 2, 3, 4, 'nuevo', 6, 7, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 768]

Notar que, al eliminar lista[4], la lista ha cambiado y luego se elimina lista[7] de la lista modificada

También se pueden ordenar los elementos de una lista numérica

sorted([3,4,1,1,2,5]) 
[1, 1, 2, 3, 4, 5]

Ahora vamos a trabajar con conjuntos. En los conjuntos, los elementos repetidos no son tomados en cuenta, se eliminan. Se
pueden construir con set() (tipo de Python) o Set() (tipo de Sage):

T=[1,2,3,56]
Set(T) 
{56, 1, 2, 3}
A = Set(['a', 1, 2, 'b', 4, 'd', 'c', 3])
A 
{'a', 1, 2, 'b', 4, 'd', 'c', 3}

2. Operaciones entre conjuntos

Sage proporciona funciones para realizar la unión, intersección, diferencia y diferencia simétrica entre conjuntos:

B = Set(['a',1,'e',5])
A.difference(B) 
{'c', 3, 4, 'd', 'b', 2}

4 de 9
 A.symmetric_difference(B) 
{2, 'b', 'e', 5, 'c', 3, 4, 'd'}
union(A,B) 
['a', 1, 2, 'b', 4, 'd', 'c', 3, 'e', 5]
A.union(B) 
{'a', 1, 2, 'b', 4, 'd', 'c', 3, 'e', 5}
A.intersection(B) 
{'a', 1}
union? 

File: /Applications/Sage/Sage-5.6-OSX-32bit-10.4.app/Contents/Resources/sage/local/lib/python2.7/site-packages/sage/misc
/misc.py

Type: <type ‘function’>

Definition: union(x, y=None)

Docstring:

Return the union of x and y, as a list. The resulting list need not be sorted and can change from call to call.

INPUT:

x - iterable
y - iterable (may optionally omitted)

OUTPUT: list

EXAMPLES:

sage: answer = union([1,2,3,4], [5,6]); answer

[1, 2, 3, 4, 5, 6]
sage: union([1,2,3,4,5,6], [5,6]) == answer
True
sage: union((1,2,3,4,5,6), [5,6]) == answer
True
sage: union((1,2,3,4,5,6), set([5,6])) == answer
True

Podemos obtener subconjuntos de cualquier orden de un conjunto dado. Si no se especifica el orden devuelve todos los
subconjuntos:

S = A.subsets(3)
S.list() 
[{'a', 1, 2},
{'a', 1, 'b'},
{'a', 1, 4},
{'a', 1, 'd'},
{'a', 1, 'c'},
{'a', 1, 3},
{'a', 2, 'b'},
{'a', 2, 4},
{'a', 2, 'd'},
{'a', 2, 'c'},
{'a', 2, 3},
{'a', 'b', 4},
{'a', 'b', 'd'},
{'a', 'c', 'b'},
{'a', 3, 'b'},
{'a', 4, 'd'},
{'a', 'c', 4},
{'a', 3, 4},
{'a', 'c', 'd'},
{'a', 3, 'd'},
{'a', 'c', 3},
{1, 2, 'b'},
{1, 2, 4},

5 de 9
 {1, 2, 'd'},
{1, 2, 'c'},
{1, 2, 3},
{1, 'b', 4},
{1, 'b', 'd'},
{1, 'c', 'b'},
{3, 1, 'b'},
{1, 4, 'd'},
{1, 'c', 4},
{1, 3, 4},
{1, 'c', 'd'},
{1, 3, 'd'},
{1, 'c', 3},
{2, 'b', 4},
{2, 'b', 'd'},
{2, 'b', 'c'},
{3, 2, 'b'},
{2, 4, 'd'},
{2, 4, 'c'},
{2, 3, 4},
{'c', 2, 'd'},
{2, 3, 'd'},
{2, 3, 'c'},
{'b', 4, 'd'},
{'c', 'b', 4},
{3, 'b', 4},
{'c', 'b', 'd'},
{3, 'b', 'd'},
{3, 'c', 'b'},
{'c', 4, 'd'},
{3, 4, 'd'},
{'c', 3, 4},
{'c', 3, 'd'}]

8∗7∗6
El conjunto A tiene 6
subconjuntos de orden 3:

S.cardinality() 
56

Sage tiene conjuntos de números predefinidos, con los que también se puede trabajar. Por ejemplo, ZZ representa el conjunto de
los números enteros:

C=Set(ZZ)
C.cardinality() 
+Infinity
A.difference(C) 
{'a', 'c', 'b', 'd'}

Sage trabaja con conjuntos infinitos de forma correcta, pero no los muestra:

D = A.symmetric_difference(C)
D 
Set-theoretic symmetric difference of {'a', 1, 2, 'b', 4, 'd', 'c',
3} and Set of elements of Integer Ring

Podemos consultar si cierto elemento está o no en un conjunto y si éste es o no finito:

print 1 in D
print 5 in D
print 'a' in D 
False
True
True
A.is_finite() 
True

6 de 9
 C.is_finite();C.cardinality() 
False
+Infinity
D.is_finite();D.cardinality() 
False
+Infinity

Se pueden hacer uniones de modo que sean forzosamente disjuntas, teniendo así elementos repetidos:

U = DisjointUnionEnumeratedSets((A,B))
U.cardinality() 
12
U.list() # Lista asociada a este conjunto 
['a', 1, 2, 'b', 4, 'd', 'c', 3, 'a', 1, 'e', 5]

3. Funciones

Sage permite al usuario definir funciones. Para ello, deben declararse previamente como variables las letras que se vayan a
utilizar en ellas:

var('x')
f(x) = x^2 +1
f(3) 
10
g(x) = x+1
f(g(x)) 
(x + 1)^2 + 1

Con la función expand podemos desarrollar el polinomio anterior.

expand(f(g(x))) 
x^2 + 2*x + 2

Como ya sabemos, la composición no es en general conmutativa:

expand(g(f(x))) 
x^2 + 2

También podemos dibujar la gráfica de una función

plot(f(x),-1,1) 

7 de 9
 Podemos calcular inversas de funciones (no en todas las ocasiones) resolviendo la ecuación:

var('y')
solve(ln(sin(x)) == y, x) 
[x == arcsin(e^y)]

4. Ejercicios

Ejercicio 1.- Crea una lista formada por los primos gemelos menores que 1000. Transforma esta lista en un conjunto A. ¿Cuántos
elementos hay en A? Nota: los primos gemelos son pares de números primos separados por dos unidades, como por ejemplo el
11 y el 13.

Ejercicio 2.- Estudia el funcionamiento de funciones para crear listas aleatorias como randrange. Úsala para crear otro conjunto
B, a partir de considerar una lista de un número de elementos aleatorios entre 0 y 1000 que tenga el mismo cardinal que A.
Calcula el cardinal de B y analiza los resultados.

Ejercicio 3.- Calcula la unión, la intersección y la diferencia simétrica de A y B, así como el cardinal de todos estos conjuntos.
Comprueba que se cumple el principio de inclusión-exclusión, es decir, que |A B| = |A| + |B| − |A ∩ B| .

Ejercicio 4.- Estudia el funcionamiento de la orden SetPartitions y úsala para obtener las particiones del conjunto V = {a, e, i, o,
u} en dos subconjuntos y el número total de particiones de V .

Ejercicio 5.- Contrasta los resultados obtenidos con el uso de las funciones bell_number y stirling_number2.

Ejercicio 6.- No hay que confundir las órdenes anteriores con las órdenes Partitions o number_of_partitions. Busca en la ayuda
qué hacen y para qué se utilizan. Como aplicación, calcula de cuántas formas puedo partir el número 10 y encuentra dichas
particiones.

Ejercicio 7.- Determina si la función f(x) = x2 − 1 tiene inversa. En su caso, dibújala. Lo mismo para g(x) = x3 − 1. En este
último caso compónla con la función h(x) = (x + 1)1/3 .

8 de 9
  

9 de 9