def _multi_variate(base_ring, num_gens=None, names=None,
order='negdeglex', default_prec=None, sparse=False):
"""
Construct multivariate power series ring.
TESTS::
"""
if names is None:
raise TypeError("you must specify a variable name or names")
if num_gens is None:
if isinstance(names,str):
num_gens = len(names.split(','))
elif isinstance(names, (list, tuple)):
num_gens = len(names)
else:
raise TypeError("variable names must be a string, tuple or list")
names = normalize_names(num_gens, names)
num_gens = len(names)
if default_prec is None:
default_prec = 12
if base_ring not in commutative_rings.CommutativeRings():
raise TypeError, "base_ring must be a commutative ring"
from sage.rings.multi_power_series_ring import MPowerSeriesRing_generic
R = MPowerSeriesRing_generic(base_ring, num_gens, names,
order=order, default_prec=default_prec, sparse=sparse)
return R
def _multi_variate(base_ring, num_gens=None, names=None,
order='negdeglex', default_prec=None, sparse=False):
"""
Construct multivariate power series ring.
TESTS::
"""
if names is None:
raise TypeError("you must specify a variable name or names")
if num_gens is None:
if isinstance(names,str):
num_gens = len(names.split(','))
elif isinstance(names, (list, tuple)):
num_gens = len(names)
else:
raise TypeError("variable names must be a string, tuple or list")
names = normalize_names(num_gens, names)
num_gens = len(names)
if default_prec is None:
default_prec = 12
if base_ring not in commutative_rings.CommutativeRings():
raise TypeError("base_ring must be a commutative ring")
from sage.rings.multi_power_series_ring import MPowerSeriesRing_generic
R = MPowerSeriesRing_generic(base_ring, num_gens, names,
order=order, default_prec=default_prec, sparse=sparse)
return R
def FreeGroup(n=None, names="x"):
"""
Construct a Free Group
INPUT:
- ``n`` -- integer or ``None`` (default). The nnumber of
generators. If not specified the ``names`` are counted.
- ``names`` -- string or list/tuple/iterable of strings (default:
``'x'``). The generator names or name prefix.
EXAMPLES::
sage: G.<a,b> = FreeGroup(); G
Free Group on generators {a, b}
sage: H = FreeGroup('a, b')
sage: G is H
True
sage: FreeGroup(0)
Free Group on generators {}
The entry can be either a string with the names of the generators,
or the number of generators and the prefix of the names to be
given. The default prefix is ``'x'`` ::
sage: FreeGroup(3)
Free Group on generators {x0, x1, x2}
sage: FreeGroup(3, 'g')
Free Group on generators {g0, g1, g2}
sage: FreeGroup()
Free Group on generators {x}
TESTS::
sage: G1 = FreeGroup(2, 'a,b')
sage: G2 = FreeGroup('a,b')
sage: G3.<a,b> = FreeGroup()
sage: G1 is G2, G2 is G3
(True, True)
"""
# Support Freegroup('a,b') syntax
if n is not None:
try:
n = Integer(n)
except TypeError:
names = n
n = None
# derive n from counting names
if n is None:
if isinstance(names, basestring):
n = len(names.split(","))
else:
names = list(names)
n = len(names)
from sage.structure.parent import normalize_names
names = tuple(normalize_names(n, names))
return FreeGroup_class(names)
def FreeGroup(n=None, names='x'):
"""
Construct a Free Group
INPUT:
- ``n`` -- integer or ``None`` (default). The nnumber of
generators. If not specified the ``names`` are counted.
- ``names`` -- string or list/tuple/iterable of strings (default:
``'x'``). The generator names or name prefix.
EXAMPLES::
sage: G.<a,b> = FreeGroup(); G
Free Group on generators {a, b}
sage: H = FreeGroup('a, b')
sage: G is H
True
sage: FreeGroup(0)
Free Group on generators {}
The entry can be either a string with the names of the generators,
or the number of generators and the prefix of the names to be
given. The default prefix is ``'x'`` ::
sage: FreeGroup(3)
Free Group on generators {x0, x1, x2}
sage: FreeGroup(3, 'g')
Free Group on generators {g0, g1, g2}
sage: FreeGroup()
Free Group on generators {x}
TESTS::
sage: G1 = FreeGroup(2, 'a,b')
sage: G2 = FreeGroup('a,b')
sage: G3.<a,b> = FreeGroup()
sage: G1 is G2, G2 is G3
(True, True)
"""
# Support Freegroup('a,b') syntax
if n is not None:
try:
n = Integer(n)
except TypeError:
names = n
n = None
# derive n from counting names
if n is None:
if isinstance(names, basestring):
n = len(names.split(','))
else:
names = list(names)
n = len(names)
from sage.structure.parent import normalize_names
names = tuple(normalize_names(n, names))
return FreeGroup_class(names)
def BraidGroup(n=None, names="s"):
"""
Construct a Braid Group
INPUT:
- ``n`` -- integer or ``None`` (default). The number of
strands. If not specified the ``names`` are counted and the
group is assumed to have one more strand than generators.
- ``names`` -- string or list/tuple/iterable of strings (default:
``'x'``). The generator names or name prefix.
EXAMPLES::
sage: B.<a,b> = BraidGroup(); B
Braid group on 3 strands
sage: H = BraidGroup('a, b')
sage: B is H
True
sage: BraidGroup(3)
Braid group on 3 strands
The entry can be either a string with the names of the generators,
or the number of generators and the prefix of the names to be
given. The default prefix is ``'s'`` ::
sage: B=BraidGroup(3); B.generators()
(s0, s1)
sage: BraidGroup(3, 'g').generators()
(g0, g1)
TESTS::
sage: G1 = BraidGroup(3, 'a,b')
sage: G2 = BraidGroup('a,b')
sage: G3.<a,b> = BraidGroup()
sage: G1 is G2, G2 is G3
(True, True)
"""
# Support Freegroup('a,b') syntax
if n is not None:
try:
n = Integer(n) - 1
except TypeError:
names = n
n = None
# derive n from counting names
if n is None:
if isinstance(names, basestring):
n = len(names.split(","))
else:
names = list(names)
n = len(names)
from sage.structure.parent import normalize_names
names = tuple(normalize_names(n, names))
return BraidGroup_class(names)
def BraidGroup(n=None, names='s'):
"""
Construct a Braid Group
INPUT:
- ``n`` -- integer or ``None`` (default). The number of
strands. If not specified the ``names`` are counted and the
group is assumed to have one more strand than generators.
- ``names`` -- string or list/tuple/iterable of strings (default:
``'x'``). The generator names or name prefix.
EXAMPLES::
sage: B.<a,b> = BraidGroup(); B
Braid group on 3 strands
sage: H = BraidGroup('a, b')
sage: B is H
True
sage: BraidGroup(3)
Braid group on 3 strands
The entry can be either a string with the names of the generators,
or the number of generators and the prefix of the names to be
given. The default prefix is ``'s'`` ::
sage: B=BraidGroup(3); B.generators()
(s0, s1)
sage: BraidGroup(3, 'g').generators()
(g0, g1)
TESTS::
sage: G1 = BraidGroup(3, 'a,b')
sage: G2 = BraidGroup('a,b')
sage: G3.<a,b> = BraidGroup()
sage: G1 is G2, G2 is G3
(True, True)
"""
# Support Freegroup('a,b') syntax
if n is not None:
try:
n = Integer(n)-1
except TypeError:
names = n
n = None
# derive n from counting names
if n is None:
if isinstance(names, basestring):
n = len(names.split(','))
else:
names = list(names)
n = len(names)
from sage.structure.parent import normalize_names
names = tuple(normalize_names(n, names))
return BraidGroup_class(names)
def PowerSeriesRing(base_ring, name=None, arg2=None, names=None,
sparse=False, default_prec=None, order='negdeglex', num_gens=None):
r"""
Create a univariate or multivariate power series ring over a given
(commutative) base ring.
INPUT:
- ``base_ring`` - a commutative ring
- ``name``, ``names`` - name(s) of the indeterminate
- ``default_prec`` - the default precision used if an exact object must
be changed to an approximate object in order to do an arithmetic
operation. If left as ``None``, it will be set to 20 in the
univariate case, and 12 in the multivariate case.
- ``sparse`` - (default: ``False``) whether power series
are represented as sparse objects.
- ``order`` - (default: ``negdeglex``) term ordering, for multivariate case
- ``num_gens`` - number of generators, for multivariate case
There is a unique power series ring over each base ring with given
variable name. Two power series over the same base ring with
different variable names are not equal or isomorphic.
EXAMPLES (Univariate)::
sage: R = PowerSeriesRing(QQ, 'x'); R
Power Series Ring in x over Rational Field
::
sage: S = PowerSeriesRing(QQ, 'y'); S
Power Series Ring in y over Rational Field
::
sage: R = PowerSeriesRing(QQ, 10)
Traceback (most recent call last):
...
ValueError: first letter of variable name must be a letter: 10
::
sage: S = PowerSeriesRing(QQ, 'x', default_prec = 15); S
Power Series Ring in x over Rational Field
sage: S.default_prec()
15
EXAMPLES (Multivariate) See also :doc:`multi_power_series_ring`::
sage: R = PowerSeriesRing(QQ, 't,u,v'); R
Multivariate Power Series Ring in t, u, v over Rational Field
::
sage: N = PowerSeriesRing(QQ,'w',num_gens=5); N
Multivariate Power Series Ring in w0, w1, w2, w3, w4 over Rational Field
Number of generators can be specified before variable name without using keyword::
sage: M = PowerSeriesRing(QQ,4,'k'); M
Multivariate Power Series Ring in k0, k1, k2, k3 over Rational Field
Multivariate power series can be constructed using angle bracket or double square bracket notation::
sage: R.<t,u,v> = PowerSeriesRing(QQ, 't,u,v'); R
Multivariate Power Series Ring in t, u, v over Rational Field
sage: ZZ[['s,t,u']]
Multivariate Power Series Ring in s, t, u over Integer Ring
Sparse multivariate power series ring::
sage: M = PowerSeriesRing(QQ,4,'k',sparse=True); M
Sparse Multivariate Power Series Ring in k0, k1, k2, k3 over
Rational Field
Power series ring over polynomial ring::
sage: H = PowerSeriesRing(PolynomialRing(ZZ,3,'z'),4,'f'); H
Multivariate Power Series Ring in f0, f1, f2, f3 over Multivariate
Polynomial Ring in z0, z1, z2 over Integer Ring
Power series ring over finite field::
sage: S = PowerSeriesRing(GF(65537),'x,y'); S
Multivariate Power Series Ring in x, y over Finite Field of size
65537
Power series ring with many variables::
sage: R = PowerSeriesRing(ZZ, ['x%s'%p for p in primes(100)]); R
Multivariate Power Series Ring in x2, x3, x5, x7, x11, x13, x17, x19,
x23, x29, x31, x37, x41, x43, x47, x53, x59, x61, x67, x71, x73, x79,
x83, x89, x97 over Integer Ring
- Use :meth:`inject_variables` to make the variables available for
interactive use.
::
sage: R.inject_variables()
Defining x2, x3, x5, x7, x11, x13, x17, x19, x23, x29, x31, x37,
x41, x43, x47, x53, x59, x61, x67, x71, x73, x79, x83, x89, x97
sage: f = x47 + 3*x11*x29 - x19 + R.O(3)
sage: f in R
True
Variable ordering determines how series are displayed::
sage: T.<a,b> = PowerSeriesRing(ZZ,order='deglex'); T
Multivariate Power Series Ring in a, b over Integer Ring
sage: T.term_order()
Degree lexicographic term order
sage: p = - 2*b^6 + a^5*b^2 + a^7 - b^2 - a*b^3 + T.O(9); p
a^7 + a^5*b^2 - 2*b^6 - a*b^3 - b^2 + O(a, b)^9
sage: U = PowerSeriesRing(ZZ,'a,b',order='negdeglex'); U
Multivariate Power Series Ring in a, b over Integer Ring
sage: U.term_order()
Negative degree lexicographic term order
sage: U(p)
-b^2 - a*b^3 - 2*b^6 + a^7 + a^5*b^2 + O(a, b)^9
TESTS::
sage: N = PowerSeriesRing(QQ,'k',num_gens=5); N
Multivariate Power Series Ring in k0, k1, k2, k3, k4 over Rational Field
The following behavior of univariate power series ring will eventually
be deprecated and then changed to return a multivariate power series
ring::
sage: N = PowerSeriesRing(QQ,'k',5); N
Power Series Ring in k over Rational Field
sage: N.default_prec()
5
sage: L.<m> = PowerSeriesRing(QQ,5); L
Power Series Ring in m over Rational Field
sage: L.default_prec()
5
By :trac:`14084`, a power series ring belongs to the category of integral
domains, if the base ring does::
sage: P = ZZ[['x']]
sage: P.category()
Category of integral domains
sage: TestSuite(P).run()
sage: M = ZZ[['x','y']]
sage: M.category()
Category of integral domains
sage: TestSuite(M).run()
Otherwise, it belongs to the category of commutative rings::
sage: P = Integers(15)[['x']]
sage: P.category()
Category of commutative rings
sage: TestSuite(P).run()
sage: M = Integers(15)[['x','y']]
sage: M.category()
Category of commutative rings
sage: TestSuite(M).run()
"""
#multivariate case:
# examples for first case:
# PowerSeriesRing(QQ,'x,y,z')
# PowerSeriesRing(QQ,['x','y','z'])
# PowerSeriesRing(QQ,['x','y','z'], 3)
if names is None and name is not None:
names = name
if isinstance(names, (tuple, list)) and len(names) > 1 or (isinstance(names, str) and ',' in names):
return _multi_variate(base_ring, num_gens=arg2, names=names,
order=order, default_prec=default_prec, sparse=sparse)
# examples for second case:
# PowerSeriesRing(QQ,3,'t')
if arg2 is None and num_gens is not None:
arg2 = names
names = num_gens
if isinstance(arg2, str) and isinstance(names, (int,long,integer.Integer)):
return _multi_variate(base_ring, num_gens=names, names=arg2,
order=order, default_prec=default_prec, sparse=sparse)
# univariate case: the arguments to PowerSeriesRing used to be
# (base_ring, name=None, default_prec=20, names=None, sparse=False),
# and thus that is what the code below expects; this behavior is being
# deprecated, and will eventually be removed.
if default_prec is None and arg2 is None:
default_prec = 20
elif arg2 is not None:
default_prec = arg2
## too many things (padics, elliptic curves) depend on this behavior,
## so no warning for now.
##
# from sage.misc.superseded import deprecation
# if isinstance(name, (int,long,integer.Integer)) or isinstance(arg2,(int,long,integer.Integer)):
# deprecation(trac_number, "This behavior of PowerSeriesRing is being deprecated in favor of constructing multivariate power series rings. (See Trac ticket #1956.)")
# the following is the original, univariate-only code
if isinstance(name, (int,long,integer.Integer)):
default_prec = name
if not names is None:
name = names
try:
name = normalize_names(1, name)
except TypeError:
raise TypeError, "illegal variable name"
if name is None:
raise TypeError, "You must specify the name of the indeterminate of the Power series ring."
key = (base_ring, name, default_prec, sparse)
if PowerSeriesRing_generic.__classcall__.is_in_cache(key):
return PowerSeriesRing_generic(*key)
if isinstance(name, (tuple, list)):
assert len(name) == 1
name = name[0]
if not (name is None or isinstance(name, str)):
raise TypeError, "variable name must be a string or None"
if base_ring in _Fields:
R = PowerSeriesRing_over_field(base_ring, name, default_prec, sparse=sparse)
elif base_ring in _IntegralDomains:
R = PowerSeriesRing_domain(base_ring, name, default_prec, sparse=sparse)
elif base_ring in _CommutativeRings:
R = PowerSeriesRing_generic(base_ring, name, default_prec, sparse=sparse)
else:
raise TypeError, "base_ring must be a commutative ring"
return R
def PowerSeriesRing(base_ring,
name=None,
arg2=None,
names=None,
sparse=False,
default_prec=None,
order='negdeglex',
num_gens=None):
r"""
Create a univariate or multivariate power series ring over a given
(commutative) base ring.
INPUT:
- ``base_ring`` - a commutative ring
- ``name``, ``names`` - name(s) of the indeterminate
- ``default_prec`` - the default precision used if an exact object must
be changed to an approximate object in order to do an arithmetic
operation. If left as ``None``, it will be set to 20 in the
univariate case, and 12 in the multivariate case.
- ``sparse`` - (default: ``False``) whether power series
are represented as sparse objects.
- ``order`` - (default: ``negdeglex``) term ordering, for multivariate case
- ``num_gens`` - number of generators, for multivariate case
There is a unique power series ring over each base ring with given
variable name. Two power series over the same base ring with
different variable names are not equal or isomorphic.
EXAMPLES (Univariate)::
sage: R = PowerSeriesRing(QQ, 'x'); R
Power Series Ring in x over Rational Field
::
sage: S = PowerSeriesRing(QQ, 'y'); S
Power Series Ring in y over Rational Field
::
sage: R = PowerSeriesRing(QQ, 10)
Traceback (most recent call last):
...
ValueError: first letter of variable name must be a letter: 10
::
sage: S = PowerSeriesRing(QQ, 'x', default_prec = 15); S
Power Series Ring in x over Rational Field
sage: S.default_prec()
15
EXAMPLES (Multivariate) See also :doc:`multi_power_series_ring`::
sage: R = PowerSeriesRing(QQ, 't,u,v'); R
Multivariate Power Series Ring in t, u, v over Rational Field
::
sage: N = PowerSeriesRing(QQ,'w',num_gens=5); N
Multivariate Power Series Ring in w0, w1, w2, w3, w4 over Rational Field
Number of generators can be specified before variable name without using keyword::
sage: M = PowerSeriesRing(QQ,4,'k'); M
Multivariate Power Series Ring in k0, k1, k2, k3 over Rational Field
Multivariate power series can be constructed using angle bracket or double square bracket notation::
sage: R.<t,u,v> = PowerSeriesRing(QQ, 't,u,v'); R
Multivariate Power Series Ring in t, u, v over Rational Field
sage: ZZ[['s,t,u']]
Multivariate Power Series Ring in s, t, u over Integer Ring
Sparse multivariate power series ring::
sage: M = PowerSeriesRing(QQ,4,'k',sparse=True); M
Sparse Multivariate Power Series Ring in k0, k1, k2, k3 over
Rational Field
Power series ring over polynomial ring::
sage: H = PowerSeriesRing(PolynomialRing(ZZ,3,'z'),4,'f'); H
Multivariate Power Series Ring in f0, f1, f2, f3 over Multivariate
Polynomial Ring in z0, z1, z2 over Integer Ring
Power series ring over finite field::
sage: S = PowerSeriesRing(GF(65537),'x,y'); S
Multivariate Power Series Ring in x, y over Finite Field of size
65537
Power series ring with many variables::
sage: R = PowerSeriesRing(ZZ, ['x%s'%p for p in primes(100)]); R
Multivariate Power Series Ring in x2, x3, x5, x7, x11, x13, x17, x19,
x23, x29, x31, x37, x41, x43, x47, x53, x59, x61, x67, x71, x73, x79,
x83, x89, x97 over Integer Ring
- Use :meth:`inject_variables` to make the variables available for
interactive use.
::
sage: R.inject_variables()
Defining x2, x3, x5, x7, x11, x13, x17, x19, x23, x29, x31, x37,
x41, x43, x47, x53, x59, x61, x67, x71, x73, x79, x83, x89, x97
sage: f = x47 + 3*x11*x29 - x19 + R.O(3)
sage: f in R
True
Variable ordering determines how series are displayed::
sage: T.<a,b> = PowerSeriesRing(ZZ,order='deglex'); T
Multivariate Power Series Ring in a, b over Integer Ring
sage: T.term_order()
Degree lexicographic term order
sage: p = - 2*b^6 + a^5*b^2 + a^7 - b^2 - a*b^3 + T.O(9); p
a^7 + a^5*b^2 - 2*b^6 - a*b^3 - b^2 + O(a, b)^9
sage: U = PowerSeriesRing(ZZ,'a,b',order='negdeglex'); U
Multivariate Power Series Ring in a, b over Integer Ring
sage: U.term_order()
Negative degree lexicographic term order
sage: U(p)
-b^2 - a*b^3 - 2*b^6 + a^7 + a^5*b^2 + O(a, b)^9
TESTS::
sage: N = PowerSeriesRing(QQ,'k',num_gens=5); N
Multivariate Power Series Ring in k0, k1, k2, k3, k4 over Rational Field
The following behavior of univariate power series ring will eventually
be deprecated and then changed to return a multivariate power series
ring::
sage: N = PowerSeriesRing(QQ,'k',5); N
Power Series Ring in k over Rational Field
sage: N.default_prec()
5
sage: L.<m> = PowerSeriesRing(QQ,5); L
Power Series Ring in m over Rational Field
sage: L.default_prec()
5
By :trac:`14084`, a power series ring belongs to the category of integral
domains, if the base ring does::
sage: P = ZZ[['x']]
sage: P.category()
Category of integral domains
sage: TestSuite(P).run()
sage: M = ZZ[['x','y']]
sage: M.category()
Category of integral domains
sage: TestSuite(M).run()
Otherwise, it belongs to the category of commutative rings::
sage: P = Integers(15)[['x']]
sage: P.category()
Category of commutative rings
sage: TestSuite(P).run()
sage: M = Integers(15)[['x','y']]
sage: M.category()
Category of commutative rings
sage: TestSuite(M).run()
"""
#multivariate case:
# examples for first case:
# PowerSeriesRing(QQ,'x,y,z')
# PowerSeriesRing(QQ,['x','y','z'])
# PowerSeriesRing(QQ,['x','y','z'], 3)
if names is None and name is not None:
names = name
if isinstance(names,
(tuple, list)) and len(names) > 1 or (isinstance(names, str)
and ',' in names):
return _multi_variate(base_ring,
num_gens=arg2,
names=names,
order=order,
default_prec=default_prec,
sparse=sparse)
# examples for second case:
# PowerSeriesRing(QQ,3,'t')
if arg2 is None and num_gens is not None:
arg2 = names
names = num_gens
if isinstance(arg2, str) and isinstance(names,
(int, long, integer.Integer)):
return _multi_variate(base_ring,
num_gens=names,
names=arg2,
order=order,
default_prec=default_prec,
sparse=sparse)
# univariate case: the arguments to PowerSeriesRing used to be
# (base_ring, name=None, default_prec=20, names=None, sparse=False),
# and thus that is what the code below expects; this behavior is being
# deprecated, and will eventually be removed.
if default_prec is None and arg2 is None:
default_prec = 20
elif arg2 is not None:
default_prec = arg2
## too many things (padics, elliptic curves) depend on this behavior,
## so no warning for now.
##
# from sage.misc.superseded import deprecation
# if isinstance(name, (int,long,integer.Integer)) or isinstance(arg2,(int,long,integer.Integer)):
# deprecation(trac_number, "This behavior of PowerSeriesRing is being deprecated in favor of constructing multivariate power series rings. (See Trac ticket #1956.)")
# the following is the original, univariate-only code
if isinstance(name, (int, long, integer.Integer)):
default_prec = name
if not names is None:
name = names
try:
name = normalize_names(1, name)
except TypeError:
raise TypeError, "illegal variable name"
if name is None:
raise TypeError, "You must specify the name of the indeterminate of the Power series ring."
key = (base_ring, name, default_prec, sparse)
if PowerSeriesRing_generic.__classcall__.is_in_cache(key):
return PowerSeriesRing_generic(*key)
if isinstance(name, (tuple, list)):
assert len(name) == 1
name = name[0]
if not (name is None or isinstance(name, str)):
raise TypeError, "variable name must be a string or None"
if base_ring in _Fields:
R = PowerSeriesRing_over_field(base_ring,
name,
default_prec,
sparse=sparse)
elif base_ring in _IntegralDomains:
R = PowerSeriesRing_domain(base_ring,
name,
default_prec,
sparse=sparse)
elif base_ring in _CommutativeRings:
R = PowerSeriesRing_generic(base_ring,
name,
default_prec,
sparse=sparse)
else:
raise TypeError, "base_ring must be a commutative ring"
return R
def BraidGroup(n=None, names='s'):
"""
Construct a Braid Group
INPUT:
- ``n`` -- integer or ``None`` (default). The number of
strands. If not specified the ``names`` are counted and the
group is assumed to have one more strand than generators.
- ``names`` -- string or list/tuple/iterable of strings (default:
``'x'``). The generator names or name prefix.
EXAMPLES::
sage: B.<a,b> = BraidGroup(); B
Braid group on 3 strands
sage: H = BraidGroup('a, b')
sage: B is H
True
sage: BraidGroup(3)
Braid group on 3 strands
The entry can be either a string with the names of the generators,
or the number of generators and the prefix of the names to be
given. The default prefix is ``'s'`` ::
sage: B=BraidGroup(3); B.generators()
(s0, s1)
sage: BraidGroup(3, 'g').generators()
(g0, g1)
Since the word problem for the braid groups is solvable, their Cayley graph
can be localy obtained as follows (see :trac:`16059`)::
sage: def ball(group, radius):
....: ret = set()
....: ret.add(group.one())
....: for length in range(1, radius):
....: for w in Words(alphabet=group.gens(), length=length):
....: ret.add(prod(w))
....: return ret
sage: B = BraidGroup(4)
sage: GB = B.cayley_graph(elements=ball(B, 4), generators=B.gens()); GB
Digraph on 31 vertices
Since the braid group has nontrivial relations, this graph contains less
vertices than the one associated to the free group (which is a tree)::
sage: F = FreeGroup(3)
sage: GF = F.cayley_graph(elements=ball(F, 4), generators=F.gens()); GF
Digraph on 40 vertices
TESTS::
sage: G1 = BraidGroup(3, 'a,b')
sage: G2 = BraidGroup('a,b')
sage: G3.<a,b> = BraidGroup()
sage: G1 is G2, G2 is G3
(True, True)
"""
# Support Freegroup('a,b') syntax
if n is not None:
try:
n = Integer(n)-1
except TypeError:
names = n
n = None
# derive n from counting names
if n is None:
if isinstance(names, six.string_types):
n = len(names.split(','))
else:
names = list(names)
n = len(names)
from sage.structure.parent import normalize_names
names = tuple(normalize_names(n, names))
return BraidGroup_class(names)
def FreeGroup(n=None, names='x', index_set=None, abelian=False, **kwds):
"""
Construct a Free Group.
INPUT:
- ``n`` -- integer or ``None`` (default). The nnumber of
generators. If not specified the ``names`` are counted.
- ``names`` -- string or list/tuple/iterable of strings (default:
``'x'``). The generator names or name prefix.
- ``index_set`` -- (optional) an index set for the generators; if
specified then the optional keyword ``abelian`` can be used
- ``abelian`` -- (default: ``False``) whether to construct a free
abelian group or a free group
.. NOTE::
If you want to create a free group, it is currently preferential to
use ``Groups().free(...)`` as that does not load GAP.
EXAMPLES::
sage: G.<a,b> = FreeGroup(); G
Free Group on generators {a, b}
sage: H = FreeGroup('a, b')
sage: G is H
True
sage: FreeGroup(0)
Free Group on generators {}
The entry can be either a string with the names of the generators,
or the number of generators and the prefix of the names to be
given. The default prefix is ``'x'`` ::
sage: FreeGroup(3)
Free Group on generators {x0, x1, x2}
sage: FreeGroup(3, 'g')
Free Group on generators {g0, g1, g2}
sage: FreeGroup()
Free Group on generators {x}
We give two examples using the ``index_set`` option::
sage: FreeGroup(index_set=ZZ)
Free group indexed by Integer Ring
sage: FreeGroup(index_set=ZZ, abelian=True)
Free abelian group indexed by Integer Ring
TESTS::
sage: G1 = FreeGroup(2, 'a,b')
sage: G2 = FreeGroup('a,b')
sage: G3.<a,b> = FreeGroup()
sage: G1 is G2, G2 is G3
(True, True)
"""
# Support Freegroup('a,b') syntax
if n is not None:
try:
n = Integer(n)
except TypeError:
names = n
n = None
# derive n from counting names
if n is None:
if isinstance(names, basestring):
n = len(names.split(','))
else:
names = list(names)
n = len(names)
from sage.structure.parent import normalize_names
names = tuple(normalize_names(n, names))
if index_set is not None or abelian:
if abelian:
from sage.groups.indexed_free_group import IndexedFreeAbelianGroup
return IndexedFreeAbelianGroup(index_set, names=names, **kwds)
from sage.groups.indexed_free_group import IndexedFreeGroup
return IndexedFreeGroup(index_set, names=names, **kwds)
return FreeGroup_class(names)
def FreeGroup(n=None, names='x', index_set=None, abelian=False, **kwds):
"""
Construct a Free Group.
INPUT:
- ``n`` -- integer or ``None`` (default). The nnumber of
generators. If not specified the ``names`` are counted.
- ``names`` -- string or list/tuple/iterable of strings (default:
``'x'``). The generator names or name prefix.
- ``index_set`` -- (optional) an index set for the generators; if
specified then the optional keyword ``abelian`` can be used
- ``abelian`` -- (default: ``False``) whether to construct a free
abelian group or a free group
.. NOTE::
If you want to create a free group, it is currently preferential to
use ``Groups().free(...)`` as that does not load GAP.
EXAMPLES::
sage: G.<a,b> = FreeGroup(); G
Free Group on generators {a, b}
sage: H = FreeGroup('a, b')
sage: G is H
True
sage: FreeGroup(0)
Free Group on generators {}
The entry can be either a string with the names of the generators,
or the number of generators and the prefix of the names to be
given. The default prefix is ``'x'`` ::
sage: FreeGroup(3)
Free Group on generators {x0, x1, x2}
sage: FreeGroup(3, 'g')
Free Group on generators {g0, g1, g2}
sage: FreeGroup()
Free Group on generators {x}
We give two examples using the ``index_set`` option::
sage: FreeGroup(index_set=ZZ)
Free group indexed by Integer Ring
sage: FreeGroup(index_set=ZZ, abelian=True)
Free abelian group indexed by Integer Ring
TESTS::
sage: G1 = FreeGroup(2, 'a,b')
sage: G2 = FreeGroup('a,b')
sage: G3.<a,b> = FreeGroup()
sage: G1 is G2, G2 is G3
(True, True)
"""
# Support Freegroup('a,b') syntax
if n is not None:
try:
n = Integer(n)
except TypeError:
names = n
n = None
# derive n from counting names
if n is None:
if isinstance(names, basestring):
n = len(names.split(','))
else:
names = list(names)
n = len(names)
from sage.structure.parent import normalize_names
names = tuple(normalize_names(n, names))
if index_set is not None or abelian:
if abelian:
from sage.groups.indexed_free_group import IndexedFreeAbelianGroup
return IndexedFreeAbelianGroup(index_set, names=names, **kwds)
from sage.groups.indexed_free_group import IndexedFreeGroup
return IndexedFreeGroup(index_set, names=names, **kwds)
return FreeGroup_class(names)
