Coverage for local/lib/python2.7/site-packages/sage/sets/set.py : 59%

""" 

Sets 

AUTHORS: 

- William Stein (2005) - first version 

- William Stein (2006-02-16) - large number of documentation and 

examples; improved code 

- Mike Hansen (2007-3-25) - added differences and symmetric 

differences; fixed operators 

- Florent Hivert (2010-06-17) - Adapted to categories 

- Nicolas M. Thiery (2011-03-15) - Added subset and superset methods 

- Julian Rueth (2013-04-09) - Collected common code in 

:class:`Set_object_binary`, fixed ``__hash__``. 

""" 

#***************************************************************************** 

# Copyright (C) 2005 William Stein <wstein@gmail.com> 

# 2013 Julian Rueth <julian.rueth@fsfe.org> 

# 

# Distributed under the terms of the GNU General Public License (GPL) 

# 

# This code is distributed in the hope that it will be useful, 

# but WITHOUT ANY WARRANTY; without even the implied warranty of 

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 

# General Public License for more details. 

# 

# The full text of the GPL is available at: 

# 

# http://www.gnu.org/licenses/ 

#***************************************************************************** 

from __future__ import print_function 

import six 

from six import integer_types 

from sage.misc.latex import latex 

from sage.misc.prandom import choice 

from sage.misc.misc import is_iterator 

from sage.structure.category_object import CategoryObject 

from sage.structure.element import Element 

from sage.structure.parent import Parent, Set_generic 

from sage.structure.richcmp import richcmp_method, richcmp, rich_to_bool 

from sage.categories.sets_cat import Sets 

from sage.categories.enumerated_sets import EnumeratedSets 

import sage.rings.infinity 

def has_finite_length(obj): 

""" 

Return ``True`` if ``obj`` is known to have finite length. 

This is mainly meant for pure Python types, so we do not call any 

Sage-specific methods. 

EXAMPLES:: 

sage: from sage.sets.set import has_finite_length 

sage: has_finite_length(tuple(range(10))) 

True 

sage: has_finite_length(list(range(10))) 

True 

sage: has_finite_length(set(range(10))) 

True 

sage: has_finite_length(iter(range(10))) 

False 

sage: has_finite_length(GF(17^127)) 

True 

sage: has_finite_length(ZZ) 

False 

""" 

try: 

len(obj) 

except OverflowError: 

return True 

except Exception: 

return False 

else: 

return True 

def Set(X=[]): 

r""" 

Create the underlying set of ``X``. 

If ``X`` is a list, tuple, Python set, or ``X.is_finite()`` is 

``True``, this returns a wrapper around Python's enumerated immutable 

``frozenset`` type with extra functionality. Otherwise it returns a 

more formal wrapper. 

If you need the functionality of mutable sets, use Python's 

builtin set type. 

EXAMPLES:: 

sage: X = Set(GF(9,'a')) 

sage: X 

{0, 1, 2, a, a + 1, a + 2, 2*a, 2*a + 1, 2*a + 2} 

sage: type(X) 

<class 'sage.sets.set.Set_object_enumerated_with_category'> 

sage: Y = X.union(Set(QQ)) 

sage: Y 

Set-theoretic union of {0, 1, 2, a, a + 1, a + 2, 2*a, 2*a + 1, 2*a + 2} and Set of elements of Rational Field 

sage: type(Y) 

<class 'sage.sets.set.Set_object_union_with_category'> 

Usually sets can be used as dictionary keys. 

:: 

sage: d={Set([2*I,1+I]):10} 

sage: d # key is randomly ordered 

{{I + 1, 2*I}: 10} 

sage: d[Set([1+I,2*I])] 

10 

sage: d[Set((1+I,2*I))] 

10 

The original object is often forgotten. 

:: 

sage: v = [1,2,3] 

sage: X = Set(v) 

sage: X 

{1, 2, 3} 

sage: v.append(5) 

sage: X 

{1, 2, 3} 

sage: 5 in X 

False 

Set also accepts iterators, but be careful to only give *finite* 

sets:: 

sage: from six.moves import range 

sage: sorted(Set(range(1,6))) 

[1, 2, 3, 4, 5] 

sage: sorted(Set(list(range(1,6)))) 

[1, 2, 3, 4, 5] 

sage: sorted(Set(iter(range(1,6)))) 

[1, 2, 3, 4, 5] 

We can also create sets from different types:: 

sage: sorted(Set([Sequence([3,1], immutable=True), 5, QQ, Partition([3,1,1])]), key=str) 

[5, Rational Field, [3, 1, 1], [3, 1]] 

Sets with unhashable objects work, but with less functionality:: 

sage: A = Set([QQ, (3, 1), 5]) # hashable 

sage: sorted(A.list(), key=repr) 

[(3, 1), 5, Rational Field] 

sage: type(A) 

<class 'sage.sets.set.Set_object_enumerated_with_category'> 

sage: B = Set([QQ, [3, 1], 5]) # unhashable 

sage: sorted(B.list(), key=repr) 

Traceback (most recent call last): 

... 

AttributeError: 'Set_object_with_category' object has no attribute 'list' 

sage: type(B) 

<class 'sage.sets.set.Set_object_with_category'> 

TESTS:: 

sage: Set(Primes()) 

Set of all prime numbers: 2, 3, 5, 7, ... 

sage: Set(Subsets([1,2,3])).cardinality() 

8 

sage: S = Set(iter([1,2,3])); S 

{1, 2, 3} 

sage: type(S) 

<class 'sage.sets.set.Set_object_enumerated_with_category'> 

sage: S = Set([]) 

sage: TestSuite(S).run() 

Check that :trac:`16090` is fixed:: 

sage: Set() 

{} 

""" 

if isinstance(X, CategoryObject): 

if isinstance(X, Set_generic): 

return X 

elif X in Sets().Finite(): 

return Set_object_enumerated(X) 

else: 

return Set_object(X) 

if isinstance(X, Element): 

raise TypeError("Element has no defined underlying set") 

try: 

X = frozenset(X) 

except TypeError: 

return Set_object(X) 

else: 

return Set_object_enumerated(X) 

@richcmp_method 

class Set_object(Set_generic): 

r""" 

A set attached to an almost arbitrary object. 

EXAMPLES:: 

sage: K = GF(19) 

sage: Set(K) 

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18} 

sage: S = Set(K) 

sage: latex(S) 

\left\{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18\right\} 

sage: TestSuite(S).run() 

sage: latex(Set(ZZ)) 

\Bold{Z} 

TESTS: 

See trac ticket :trac:`14486`:: 

sage: 0 == Set([1]), Set([1]) == 0 

(False, False) 

sage: 1 == Set([0]), Set([0]) == 1 

(False, False) 

""" 

def __init__(self, X, category=None): 

""" 

Create a Set_object 

This function is called by the Set function; users 

shouldn't call this directly. 

EXAMPLES:: 

sage: type(Set(QQ)) 

<class 'sage.sets.set.Set_object_with_category'> 

sage: Set(QQ).category() 

Category of sets 

TESTS:: 

sage: _a, _b = get_coercion_model().canonical_coercion(Set([0]), 0) 

Traceback (most recent call last): 

... 

TypeError: no common canonical parent for objects with parents: 

'<class 'sage.sets.set.Set_object_enumerated_with_category'>' 

and 'Integer Ring' 

""" 

from sage.rings.integer import is_Integer 

if isinstance(X, integer_types) or is_Integer(X): 

# The coercion model will try to call Set_object(0) 

raise ValueError('underlying object cannot be an integer') 

if category is None: 

category = Sets() 

Parent.__init__(self, category=category) 

self.__object = X 

def __hash__(self): 

""" 

Return the hash value of ``self``. 

EXAMPLES:: 

sage: hash(Set(QQ)) == hash(QQ) 

True 

""" 

return hash(self.__object) 

def _latex_(self): 

r""" 

Return latex representation of this set. 

This is often the same as the latex representation of this 

object when the object is infinite. 

EXAMPLES:: 

sage: latex(Set(QQ)) 

\Bold{Q} 

When the object is finite or a special set then the latex 

representation can be more interesting. 

:: 

sage: print(latex(Primes())) 

\text{\texttt{Set{ }of{ }all{ }prime{ }numbers:{ }2,{ }3,{ }5,{ }7,{ }...}} 

sage: print(latex(Set([1,1,1,5,6]))) 

\left\{1, 5, 6\right\} 

""" 

return latex(self.__object) 

def _repr_(self): 

""" 

Print representation of this set. 

EXAMPLES:: 

sage: X = Set(ZZ) 

sage: X 

Set of elements of Integer Ring 

sage: X.rename('{ integers }') 

sage: X 

{ integers } 

""" 

return "Set of elements of " + repr(self.__object) 

def __iter__(self): 

""" 

Iterate over the elements of this set. 

EXAMPLES:: 

sage: X = Set(ZZ) 

sage: I = X.__iter__() 

sage: next(I) 

0 

sage: next(I) 

1 

sage: next(I) 

-1 

sage: next(I) 

2 

""" 

return iter(self.__object) 

an_element = EnumeratedSets.ParentMethods.__dict__['_an_element_from_iterator'] 

def __contains__(self, x): 

""" 

Return ``True`` if `x` is in ``self``. 

EXAMPLES:: 

sage: X = Set(ZZ) 

sage: 5 in X 

True 

sage: GF(7)(3) in X 

True 

sage: 2/1 in X 

True 

sage: 2/1 in ZZ 

True 

sage: 2/3 in X 

False 

Finite fields better illustrate the difference between 

``__contains__`` for objects and their underlying sets. 

sage: X = Set(GF(7)) 

sage: X 

{0, 1, 2, 3, 4, 5, 6} 

sage: 5/3 in X 

False 

sage: 5/3 in GF(7) 

False 

sage: Set(GF(7)).union(Set(GF(5))) 

{0, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 0} 

sage: Set(GF(7)).intersection(Set(GF(5))) 

{} 

""" 

return x in self.__object 

def __richcmp__(self, right, op): 

r""" 

Compare ``self`` and ``right``. 

If ``right`` is not a :class:`Set_object`, return ``NotImplemented``. 

If ``right`` is also a :class:`Set_object`, returns comparison 

on the underlying objects. 

.. NOTE:: 

If `X < Y` is true this does *not* necessarily mean 

that `X` is a subset of `Y`. Also, any two sets can be 

compared still, but the result need not be meaningful 

if they are not equal. 

EXAMPLES:: 

sage: Set(ZZ) == Set(QQ) 

False 

sage: Set(ZZ) < Set(QQ) 

True 

sage: Primes() == Set(QQ) 

False 

The following is random, illustrating that comparison of 

sets is not the subset relation, when they are not equal:: 

sage: Primes() < Set(QQ) # random 

True or False 

""" 

if not isinstance(right, Set_object): 

return NotImplemented 

return richcmp(self.__object, right.__object, op) 

def union(self, X): 

""" 

Return the union of ``self`` and ``X``. 

EXAMPLES:: 

sage: Set(QQ).union(Set(ZZ)) 

Set-theoretic union of Set of elements of Rational Field and Set of elements of Integer Ring 

sage: Set(QQ) + Set(ZZ) 

Set-theoretic union of Set of elements of Rational Field and Set of elements of Integer Ring 

sage: X = Set(QQ).union(Set(GF(3))); X 

Set-theoretic union of Set of elements of Rational Field and {0, 1, 2} 

sage: 2/3 in X 

True 

sage: GF(3)(2) in X 

True 

sage: GF(5)(2) in X 

False 

sage: Set(GF(7)) + Set(GF(3)) 

{0, 1, 2, 3, 4, 5, 6, 1, 2, 0} 

""" 

if isinstance(X, Set_generic): 

if self is X: 

return self 

return Set_object_union(self, X) 

raise TypeError("X (=%s) must be a Set"%X) 

def __add__(self, X): 

""" 

Return the union of ``self`` and ``X``. 

EXAMPLES:: 

sage: Set(RealField()) + Set(QQ^5) 

Set-theoretic union of Set of elements of Real Field with 53 bits of precision and Set of elements of Vector space of dimension 5 over Rational Field 

sage: Set(GF(3)) + Set(GF(2)) 

{0, 1, 2, 0, 1} 

sage: Set(GF(2)) + Set(GF(4,'a')) 

{0, 1, a, a + 1} 

sage: Set(GF(8,'b')) + Set(GF(4,'a')) 

{0, 1, b, b + 1, b^2, b^2 + 1, b^2 + b, b^2 + b + 1, a, a + 1, 1, 0} 

""" 

return self.union(X) 

def __or__(self, X): 

""" 

Return the union of ``self`` and ``X``. 

EXAMPLES:: 

sage: Set([2,3]) | Set([3,4]) 

{2, 3, 4} 

sage: Set(ZZ) | Set(QQ) 

Set-theoretic union of Set of elements of Integer Ring and Set of elements of Rational Field 

""" 

return self.union(X) 

def intersection(self, X): 

r""" 

Return the intersection of ``self`` and ``X``. 

EXAMPLES:: 

sage: X = Set(ZZ).intersection(Primes()) 

sage: 4 in X 

False 

sage: 3 in X 

True 

sage: 2/1 in X 

True 

sage: X = Set(GF(9,'b')).intersection(Set(GF(27,'c'))) 

sage: X 

{} 

sage: X = Set(GF(9,'b')).intersection(Set(GF(27,'b'))) 

sage: X 

{} 

""" 

if isinstance(X, Set_generic): 

if self is X: 

return self 

return Set_object_intersection(self, X) 

raise TypeError("X (=%s) must be a Set"%X) 

def difference(self, X): 

r""" 

Return the set difference ``self - X``. 

EXAMPLES:: 

sage: X = Set(ZZ).difference(Primes()) 

sage: 4 in X 

True 

sage: 3 in X 

False 

sage: 4/1 in X 

True 

sage: X = Set(GF(9,'b')).difference(Set(GF(27,'c'))) 

sage: X 

{0, 1, 2, b, b + 1, b + 2, 2*b, 2*b + 1, 2*b + 2} 

sage: X = Set(GF(9,'b')).difference(Set(GF(27,'b'))) 

sage: X 

{0, 1, 2, b, b + 1, b + 2, 2*b, 2*b + 1, 2*b + 2} 

""" 

if isinstance(X, Set_generic): 

if self is X: 

return Set([]) 

return Set_object_difference(self, X) 

raise TypeError("X (=%s) must be a Set"%X) 

def symmetric_difference(self, X): 

r""" 

Returns the symmetric difference of ``self`` and ``X``. 

EXAMPLES:: 

sage: X = Set([1,2,3]).symmetric_difference(Set([3,4])) 

sage: X 

{1, 2, 4} 

""" 

if isinstance(X, Set_generic): 

if self is X: 

return Set([]) 

return Set_object_symmetric_difference(self, X) 

raise TypeError("X (=%s) must be a Set"%X) 

def __sub__(self, X): 

""" 

Return the difference of ``self`` and ``X``. 

EXAMPLES:: 

sage: X = Set(ZZ).difference(Primes()) 

sage: Y = Set(ZZ) - Primes() 

sage: X == Y 

True 

""" 

return self.difference(X) 

def __and__(self, X): 

""" 

Returns the intersection of ``self`` and ``X``. 

EXAMPLES:: 

sage: Set([2,3]) & Set([3,4]) 

{3} 

sage: Set(ZZ) & Set(QQ) 

Set-theoretic intersection of Set of elements of Integer Ring and Set of elements of Rational Field 

""" 

return self.intersection(X) 

def __xor__(self, X): 

""" 

Returns the symmetric difference of ``self`` and ``X``. 

EXAMPLES:: 

sage: X = Set([1,2,3,4]) 

sage: Y = Set([1,2]) 

sage: X.symmetric_difference(Y) 

{3, 4} 

sage: X.__xor__(Y) 

{3, 4} 

""" 

return self.symmetric_difference(X) 

def cardinality(self): 

""" 

Return the cardinality of this set, which is either an integer or 

``Infinity``. 

EXAMPLES:: 

sage: Set(ZZ).cardinality() 

+Infinity 

sage: Primes().cardinality() 

+Infinity 

sage: Set(GF(5)).cardinality() 

5 

sage: Set(GF(5^2,'a')).cardinality() 

25 

""" 

if not self.is_finite(): 

return sage.rings.infinity.infinity 

if self is not self.__object: 

try: 

return self.__object.cardinality() 

except (AttributeError, NotImplementedError): 

pass 

from sage.rings.integer import Integer 

try: 

return Integer(len(self.__object)) 

except TypeError: 

pass 

raise NotImplementedError("computation of cardinality of %s not yet implemented"%self.__object) 

def is_empty(self): 

""" 

Return boolean representing emptiness of the set. 

OUTPUT: 

True if the set is empty, false if otherwise. 

EXAMPLES:: 

sage: Set([]).is_empty() 

True 

sage: Set([0]).is_empty() 

False 

sage: Set([1..100]).is_empty() 

False 

sage: Set(SymmetricGroup(2).list()).is_empty() 

False 

sage: Set(ZZ).is_empty() 

False 

TESTS:: 

sage: Set([]).is_empty() 

True 

sage: Set([1,2,3]).is_empty() 

False 

sage: Set([1..100]).is_empty() 

False 

sage: Set(DihedralGroup(4).list()).is_empty() 

False 

sage: Set(QQ).is_empty() 

False 

""" 

return not self 

def is_finite(self): 

""" 

Return ``True`` if ``self`` is finite. 

EXAMPLES:: 

sage: Set(QQ).is_finite() 

False 

sage: Set(GF(250037)).is_finite() 

True 

sage: Set(Integers(2^1000000)).is_finite() 

True 

sage: Set([1,'a',ZZ]).is_finite() 

True 

""" 

obj = self.__object 

try: 

is_finite = obj.is_finite 

except AttributeError: 

return has_finite_length(obj) 

else: 

return is_finite() 

def object(self): 

""" 

Return underlying object. 

EXAMPLES:: 

sage: X = Set(QQ) 

sage: X.object() 

Rational Field 

sage: X = Primes() 

sage: X.object() 

Set of all prime numbers: 2, 3, 5, 7, ... 

""" 

return self.__object 

def subsets(self,size=None): 

""" 

Return the :class:`Subsets` object representing the subsets of a set. 

If size is specified, return the subsets of that size. 

EXAMPLES:: 

sage: X = Set([1,2,3]) 

sage: list(X.subsets()) 

[{}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}] 

sage: list(X.subsets(2)) 

[{1, 2}, {1, 3}, {2, 3}] 

""" 

from sage.combinat.subset import Subsets 

return Subsets(self,size) 

class Set_object_enumerated(Set_object): 

""" 

A finite enumerated set. 

""" 

def __init__(self, X): 

r""" 

Initialize ``self``. 

EXAMPLES:: 

sage: S = Set(GF(19)); S 

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18} 

sage: S.category() 

Category of finite sets 

sage: print(latex(S)) 

\left\{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18\right\} 

sage: TestSuite(S).run() 

""" 

Set_object.__init__(self, X, category=Sets().Finite()) 

def random_element(self): 

r""" 

Return a random element in this set. 

EXAMPLES:: 

sage: Set([1,2,3]).random_element() # random 

2 

""" 

try: 

return self.object().random_element() 

except AttributeError: 

# TODO: this very slow! 

return choice(self.list()) 

def is_finite(self): 

r""" 

Return ``True`` as this is a finite set. 

EXAMPLES:: 

sage: Set(GF(19)).is_finite() 

True 

""" 

return True 

def cardinality(self): 

""" 

Return the cardinality of ``self``. 

EXAMPLES:: 

sage: Set([1,1]).cardinality() 

1 

""" 

from sage.rings.integer import Integer 

return Integer(len(self.set())) 

def __len__(self): 

""" 

EXAMPLES:: 

sage: len(Set([1,1])) 

1 

""" 

return len(self.set()) 

def __iter__(self): 

r""" 

Iterating through the elements of ``self``. 

EXAMPLES:: 

sage: S = Set(GF(19)) 

sage: I = iter(S) 

sage: next(I) 

0 

sage: next(I) 

1 

sage: next(I) 

2 

sage: next(I) 

3 

""" 

return iter(self.set()) 

def _latex_(self): 

r""" 

Return the LaTeX representation of ``self``. 

EXAMPLES:: 

sage: S = Set(GF(2)) 

sage: latex(S) 

\left\{0, 1\right\} 

""" 

return '\\left\\{' + ', '.join([latex(x) for x in self.set()]) + '\\right\\}' 

def _repr_(self): 

r""" 

Return the string representation of ``self``. 

EXAMPLES:: 

sage: S = Set(GF(2)) 

sage: S 

{0, 1} 

""" 

s = repr(self.set()) 

if six.PY3: 

return s 

else: 

return "{" + s[5:-2] + "}" 

def list(self): 

""" 

Return the elements of ``self``, as a list. 

EXAMPLES:: 

sage: X = Set(GF(8,'c')) 

sage: X 

{0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1} 

sage: X.list() 

[0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1] 

sage: type(X.list()) 

<... 'list'> 

.. TODO:: 

FIXME: What should be the order of the result? 

That of ``self.object()``? Or the order given by 

``set(self.object())``? Note that :meth:`__getitem__` is 

currently implemented in term of this list method, which 

is really inefficient ... 

""" 

return list(set(self.object())) 

def set(self): 

""" 

Return the Python set object associated to this set. 

Python has a notion of finite set, and often Sage sets 

have an associated Python set. This function returns 

that set. 

EXAMPLES:: 

sage: X = Set(GF(8,'c')) 

sage: X 

{0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1} 

sage: X.set() 

{0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1} 

sage: type(X.set()) 

<... 'set'> 

sage: type(X) 

<class 'sage.sets.set.Set_object_enumerated_with_category'> 

""" 

return set(self.object()) 

def frozenset(self): 

""" 

Return the Python frozenset object associated to this set, 

which is an immutable set (hence hashable). 

EXAMPLES:: 

sage: X = Set(GF(8,'c')) 

sage: X 

{0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1} 

sage: s = X.set(); s 

{0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1} 

sage: hash(s) 

Traceback (most recent call last): 

... 

TypeError: unhashable type: 'set' 

sage: s = X.frozenset(); s 

frozenset({0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1}) 

sage: hash(s) 

-1390224788 # 32-bit 

561411537695332972 # 64-bit 

sage: type(s) 

<... 'frozenset'> 

""" 

return frozenset(self.object()) 

def __hash__(self): 

""" 

Return the hash of ``self`` (as a ``frozenset``). 

EXAMPLES:: 

sage: s = Set(GF(8,'c')) 

sage: hash(s) == hash(s) 

True 

""" 

return hash(self.frozenset()) 

def __richcmp__(self, other, op): 

""" 

Compare the sets ``self`` and ``other``. 

EXAMPLES:: 

sage: X = Set(GF(8,'c')) 

sage: X == Set(GF(8,'c')) 

True 

sage: X == Set(GF(4,'a')) 

False 

sage: Set(QQ) == Set(ZZ) 

False 

""" 

if not isinstance(other, Set_object_enumerated): 

return NotImplemented 

if self.set() == other.set(): 

return rich_to_bool(op, 0) 

return rich_to_bool(op, -1) 

def issubset(self, other): 

r""" 

Return whether ``self`` is a subset of ``other``. 

INPUT: 

- ``other`` -- a finite Set 

EXAMPLES:: 

sage: X = Set([1,3,5]) 

sage: Y = Set([0,1,2,3,5,7]) 

sage: X.issubset(Y) 

True 

sage: Y.issubset(X) 

False 

sage: X.issubset(X) 

True 

TESTS:: 

sage: len([Z for Z in Y.subsets() if Z.issubset(X)]) 

8 

""" 

if not isinstance(other, Set_object_enumerated): 

raise NotImplementedError 

return self.set().issubset(other.set()) 

def issuperset(self, other): 

r""" 

Return whether ``self`` is a superset of ``other``. 

INPUT: 

- ``other`` -- a finite Set 

EXAMPLES:: 

sage: X = Set([1,3,5]) 

sage: Y = Set([0,1,2,3,5]) 

sage: X.issuperset(Y) 

False 

sage: Y.issuperset(X) 

True 

sage: X.issuperset(X) 

True 

TESTS:: 

sage: len([Z for Z in Y.subsets() if Z.issuperset(X)]) 

4 

""" 

if not isinstance(other, Set_object_enumerated): 

raise NotImplementedError 

return self.set().issuperset(other.set()) 

def union(self, other): 

""" 

Return the union of ``self`` and ``other``. 

EXAMPLES:: 

sage: X = Set(GF(8,'c')) 

sage: Y = Set([GF(8,'c').0, 1, 2, 3]) 

sage: X 

{0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1} 

sage: Y 

{1, c, 3, 2} 

sage: X.union(Y) 

{0, 1, c, c + 1, c^2, c^2 + 1, c^2 + c, c^2 + c + 1, 2, 3} 

""" 

if not isinstance(other, Set_object_enumerated): 

return Set_object.union(self, other) 

return Set_object_enumerated(self.set().union(other.set())) 

def intersection(self, other): 

""" 

Return the intersection of ``self`` and ``other``. 

EXAMPLES:: 

sage: X = Set(GF(8,'c')) 

sage: Y = Set([GF(8,'c').0, 1, 2, 3]) 

sage: X.intersection(Y) 

{1, c} 

""" 

if not isinstance(other, Set_object_enumerated): 

return Set_object.intersection(self, other) 

return Set_object_enumerated(self.set().intersection(other.set())) 

def difference(self, other): 

""" 

Return the set difference ``self - other``. 

EXAMPLES:: 

sage: X = Set([1,2,3,4]) 

sage: Y = Set([1,2]) 

sage: X.difference(Y) 

{3, 4} 

sage: Z = Set(ZZ) 

sage: W = Set([2.5, 4, 5, 6]) 

sage: W.difference(Z) 

{2.50000000000000} 

""" 

if not isinstance(other, Set_object_enumerated): 

return Set([x for x in self if x not in other]) 

return Set_object_enumerated(self.set().difference(other.set())) 

def symmetric_difference(self, other): 

""" 

Return the symmetric difference of ``self`` and ``other``. 

EXAMPLES:: 

sage: X = Set([1,2,3,4]) 

sage: Y = Set([1,2]) 

sage: X.symmetric_difference(Y) 

{3, 4} 

sage: Z = Set(ZZ) 

sage: W = Set([2.5, 4, 5, 6]) 

sage: U = W.symmetric_difference(Z) 

sage: 2.5 in U 

True 

sage: 4 in U 

False 

sage: V = Z.symmetric_difference(W) 

sage: V == U 

True 

sage: 2.5 in V 

True 

sage: 6 in V 

False 

""" 

if not isinstance(other, Set_object_enumerated): 

return Set_object.symmetric_difference(self, other) 

return Set_object_enumerated(self.set().symmetric_difference(other.set())) 

class Set_object_binary(Set_object): 

r""" 

An abstract common base class for sets defined by a binary operation (ex. 

:class:`Set_object_union`, :class:`Set_object_intersection`, 

:class:`Set_object_difference`, and 

:class:`Set_object_symmetric_difference`). 

INPUT: 

- ``X``, ``Y`` -- sets, the operands to ``op`` 

- ``op`` -- a string describing the binary operation 

- ``latex_op`` -- a string used for rendering this object in LaTeX 

EXAMPLES:: 

sage: X = Set(QQ^2) 

sage: Y = Set(ZZ) 

sage: from sage.sets.set import Set_object_binary 

sage: S = Set_object_binary(X, Y, "union", "\\cup"); S 

Set-theoretic union of Set of elements of Vector space of dimension 2 

over Rational Field and Set of elements of Integer Ring 

""" 

def __init__(self, X, Y, op, latex_op): 

r""" 

Initialization. 

TESTS:: 

sage: from sage.sets.set import Set_object_binary 

sage: X = Set(QQ^2) 

sage: Y = Set(ZZ) 

sage: S = Set_object_binary(X, Y, "union", "\\cup") 

sage: type(S) 

<class 'sage.sets.set.Set_object_binary_with_category'> 

""" 

self._X = X 

self._Y = Y 

self._op = op 

self._latex_op = latex_op 

Set_object.__init__(self, self) 

def _repr_(self): 

r""" 

Return a string representation of this set. 

EXAMPLES:: 

sage: Set(ZZ).union(Set(GF(5))) 

Set-theoretic union of Set of elements of Integer Ring and {0, 1, 2, 3, 4} 

""" 

return "Set-theoretic {} of {} and {}".format(self._op, self._X, self._Y) 

def _latex_(self): 

r""" 

Return a latex representation of this set. 

EXAMPLES:: 

sage: latex(Set(ZZ).union(Set(GF(5)))) 

\Bold{Z} \cup \left\{0, 1, 2, 3, 4\right\} 

""" 

return latex(self._X) + self._latex_op + latex(self._Y) 

def __hash__(self): 

""" 

The hash value of this set. 

EXAMPLES: 

The hash values of equal sets are in general not equal since it is not 

decidable whether two sets are equal:: 

sage: X = Set(GF(13)).intersection(Set(ZZ)) 

sage: Y = Set(ZZ).intersection(Set(GF(13))) 

sage: hash(X) == hash(Y) 

False 

TESTS: 

Test that :trac:`14432` has been resolved:: 

sage: S = Set(ZZ).union(Set([infinity])) 

sage: T = Set(ZZ).union(Set([infinity])) 

sage: hash(S) == hash(T) 

True 

""" 

return hash((self._X, self._Y, self._op)) 

class Set_object_union(Set_object_binary): 

""" 

A formal union of two sets. 

""" 

def __init__(self, X, Y): 

r""" 

Initialize ``self``. 

EXAMPLES:: 

sage: S = Set(QQ^2) 

sage: T = Set(ZZ) 

sage: X = S.union(T); X 

Set-theoretic union of Set of elements of Vector space of dimension 2 over Rational Field and Set of elements of Integer Ring 

sage: latex(X) 

\Bold{Q}^{2} \cup \Bold{Z}