Free algebras¶
AUTHORS:
- David Kohel (2005-09)
- William Stein (2006-11-01): add all doctests; implemented many things.
- Simon King (2011-04): Put free algebras into the category framework.
Reimplement free algebra constructor, using a
UniqueFactory
for handling different implementations of free algebras. Allow degree weights for free algebras in letterplace implementation.
EXAMPLES:
sage: F = FreeAlgebra(ZZ,3,'x,y,z')
sage: F.base_ring()
Integer Ring
sage: G = FreeAlgebra(F, 2, 'm,n'); G
Free Algebra on 2 generators (m, n) over Free Algebra on 3 generators (x, y, z) over Integer Ring
sage: G.base_ring()
Free Algebra on 3 generators (x, y, z) over Integer Ring
The above free algebra is based on a generic implementation. By
trac ticket #7797, there is a different implementation
FreeAlgebra_letterplace
based on Singular’s letterplace rings. It is currently restricted to
weighted homogeneous elements and is therefore not the default. But the
arithmetic is much faster than in the generic implementation.
Moreover, we can compute Groebner bases with degree bound for its
two-sided ideals, and thus provide ideal containment tests:
sage: F.<x,y,z> = FreeAlgebra(QQ, implementation='letterplace')
sage: F
Free Associative Unital Algebra on 3 generators (x, y, z) over Rational Field
sage: I = F*[x*y+y*z,x^2+x*y-y*x-y^2]*F
sage: I.groebner_basis(degbound=4)
Twosided Ideal (y*z*y*y - y*z*y*z + y*z*z*y - y*z*z*z, y*z*y*x + y*z*y*z + y*z*z*x + y*z*z*z, y*y*z*y - y*y*z*z + y*z*z*y - y*z*z*z, y*y*z*x + y*y*z*z + y*z*z*x + y*z*z*z, y*y*y - y*y*z + y*z*y - y*z*z, y*y*x + y*y*z + y*z*x + y*z*z, x*y + y*z, x*x - y*x - y*y - y*z) of Free Associative Unital Algebra on 3 generators (x, y, z) over Rational Field
sage: y*z*y*y*z*z + 2*y*z*y*z*z*x + y*z*y*z*z*z - y*z*z*y*z*x + y*z*z*z*z*x in I
True
Positive integral degree weights for the letterplace implementation was introduced in trac ticket #7797:
sage: F.<x,y,z> = FreeAlgebra(QQ, implementation='letterplace', degrees=[2,1,3])
sage: x.degree()
2
sage: y.degree()
1
sage: z.degree()
3
sage: I = F*[x*y-y*x, x^2+2*y*z, (x*y)^2-z^2]*F
sage: Q.<a,b,c> = F.quo(I)
sage: TestSuite(Q).run()
sage: a^2*b^2
c*c
TESTS:
sage: F = FreeAlgebra(GF(5),3,'x')
sage: TestSuite(F).run()
sage: F is loads(dumps(F))
True
sage: F = FreeAlgebra(GF(5),3,'x', implementation='letterplace')
sage: TestSuite(F).run()
sage: F is loads(dumps(F))
True
sage: F.<x,y,z> = FreeAlgebra(GF(5),3)
sage: TestSuite(F).run()
sage: F is loads(dumps(F))
True
sage: F.<x,y,z> = FreeAlgebra(GF(5),3, implementation='letterplace')
sage: TestSuite(F).run()
sage: F is loads(dumps(F))
True
sage: F = FreeAlgebra(GF(5),3, ['xx', 'zba', 'Y'])
sage: TestSuite(F).run()
sage: F is loads(dumps(F))
True
sage: F = FreeAlgebra(GF(5),3, ['xx', 'zba', 'Y'], implementation='letterplace')
sage: TestSuite(F).run()
sage: F is loads(dumps(F))
True
sage: F = FreeAlgebra(GF(5),3, 'abc')
sage: TestSuite(F).run()
sage: F is loads(dumps(F))
True
sage: F = FreeAlgebra(GF(5),3, 'abc', implementation='letterplace')
sage: TestSuite(F).run()
sage: F is loads(dumps(F))
True
sage: F = FreeAlgebra(FreeAlgebra(ZZ,2,'ab'), 2, 'x')
sage: TestSuite(F).run()
sage: F is loads(dumps(F))
True
Note that the letterplace implementation can only be used if the corresponding (multivariate) polynomial ring has an implementation in Singular:
sage: FreeAlgebra(FreeAlgebra(ZZ,2,'ab'), 2, 'x', implementation='letterplace')
Traceback (most recent call last):
...
NotImplementedError: The letterplace implementation is not available for the free algebra you requested
-
class
sage.algebras.free_algebra.
FreeAlgebraFactory
¶ Bases:
sage.structure.factory.UniqueFactory
A constructor of free algebras.
See
free_algebra
for examples and corner cases.EXAMPLES:
sage: FreeAlgebra(GF(5),3,'x') Free Algebra on 3 generators (x0, x1, x2) over Finite Field of size 5 sage: F.<x,y,z> = FreeAlgebra(GF(5),3) sage: (x+y+z)^2 x^2 + x*y + x*z + y*x + y^2 + y*z + z*x + z*y + z^2 sage: FreeAlgebra(GF(5),3, 'xx, zba, Y') Free Algebra on 3 generators (xx, zba, Y) over Finite Field of size 5 sage: FreeAlgebra(GF(5),3, 'abc') Free Algebra on 3 generators (a, b, c) over Finite Field of size 5 sage: FreeAlgebra(GF(5),1, 'z') Free Algebra on 1 generators (z,) over Finite Field of size 5 sage: FreeAlgebra(GF(5),1, ['alpha']) Free Algebra on 1 generators (alpha,) over Finite Field of size 5 sage: FreeAlgebra(FreeAlgebra(ZZ,1,'a'), 2, 'x') Free Algebra on 2 generators (x0, x1) over Free Algebra on 1 generators (a,) over Integer Ring
Free algebras are globally unique:
sage: F = FreeAlgebra(ZZ,3,'x,y,z') sage: G = FreeAlgebra(ZZ,3,'x,y,z') sage: F is G True sage: F.<x,y,z> = FreeAlgebra(GF(5),3) # indirect doctest sage: F is loads(dumps(F)) True sage: F is FreeAlgebra(GF(5),['x','y','z']) True sage: copy(F) is F is loads(dumps(F)) True sage: TestSuite(F).run()
By trac ticket #7797, we provide a different implementation of free algebras, based on Singular’s “letterplace rings”. Our letterplace wrapper allows for chosing positive integral degree weights for the generators of the free algebra. However, only (weighted) homogenous elements are supported. Of course, isomorphic algebras in different implementations are not identical:
sage: G = FreeAlgebra(GF(5),['x','y','z'], implementation='letterplace') sage: F == G False sage: G is FreeAlgebra(GF(5),['x','y','z'], implementation='letterplace') True sage: copy(G) is G is loads(dumps(G)) True sage: TestSuite(G).run()
sage: H = FreeAlgebra(GF(5),['x','y','z'], implementation='letterplace', degrees=[1,2,3]) sage: F != H != G True sage: H is FreeAlgebra(GF(5),['x','y','z'], implementation='letterplace', degrees=[1,2,3]) True sage: copy(H) is H is loads(dumps(H)) True sage: TestSuite(H).run()
Free algebras commute with their base ring.
sage: K.<a,b> = FreeAlgebra(QQ,2) sage: K.is_commutative() False sage: L.<c> = FreeAlgebra(K,1) sage: L.is_commutative() False sage: s = a*b^2 * c^3; s a*b^2*c^3 sage: parent(s) Free Algebra on 1 generators (c,) over Free Algebra on 2 generators (a, b) over Rational Field sage: c^3 * a * b^2 a*b^2*c^3
-
create_key
(base_ring, arg1=None, arg2=None, sparse=False, order='degrevlex', names=None, name=None, implementation=None, degrees=None)¶ Create the key under which a free algebra is stored.
TESTS:
sage: FreeAlgebra.create_key(GF(5),['x','y','z']) (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),['x','y','z'],3) (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),3,'xyz') (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),['x','y','z'], implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),['x','y','z'],3, implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),3,'xyz', implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),3,'xyz', implementation='letterplace', degrees=[1,2,3]) ((1, 2, 3), Multivariate Polynomial Ring in x, y, z, x_ over Finite Field of size 5)
-
create_object
(version, key)¶ Construct the free algebra that belongs to a unique key.
NOTE:
Of course, that method should not be called directly, since it does not use the cache of free algebras.
TESTS:
sage: FreeAlgebra.create_object('4.7.1', (QQ['x','y'],)) Free Associative Unital Algebra on 2 generators (x, y) over Rational Field sage: FreeAlgebra.create_object('4.7.1', (QQ['x','y'],)) is FreeAlgebra(QQ,['x','y']) False
-
-
class
sage.algebras.free_algebra.
FreeAlgebra_generic
(R, n, names)¶ Bases:
sage.combinat.free_module.CombinatorialFreeModule
,sage.rings.ring.Algebra
The free algebra on \(n\) generators over a base ring.
INPUT:
R
– a ringn
– an integernames
– the generator names
EXAMPLES:
sage: F.<x,y,z> = FreeAlgebra(QQ, 3); F Free Algebra on 3 generators (x, y, z) over Rational Field sage: mul(F.gens()) x*y*z sage: mul([ F.gen(i%3) for i in range(12) ]) x*y*z*x*y*z*x*y*z*x*y*z sage: mul([ F.gen(i%3) for i in range(12) ]) + mul([ F.gen(i%2) for i in range(12) ]) x*y*x*y*x*y*x*y*x*y*x*y + x*y*z*x*y*z*x*y*z*x*y*z sage: (2 + x*z + x^2)^2 + (x - y)^2 4 + 5*x^2 - x*y + 4*x*z - y*x + y^2 + x^4 + x^3*z + x*z*x^2 + x*z*x*z
TESTS:
Free algebras commute with their base ring.
sage: K.<a,b> = FreeAlgebra(QQ) sage: K.is_commutative() False sage: L.<c,d> = FreeAlgebra(K) sage: L.is_commutative() False sage: s = a*b^2 * c^3; s a*b^2*c^3 sage: parent(s) Free Algebra on 2 generators (c, d) over Free Algebra on 2 generators (a, b) over Rational Field sage: c^3 * a * b^2 a*b^2*c^3
-
Element
¶ alias of
FreeAlgebraElement
-
algebra_generators
()¶ Return the algebra generators of
self
.EXAMPLES:
sage: F = FreeAlgebra(ZZ,3,'x,y,z') sage: F.algebra_generators() Finite family {'y': y, 'x': x, 'z': z}
-
g_algebra
(relations, names=None, order='degrevlex', check=True)¶ The \(G\)-Algebra derived from this algebra by relations. By default is assumed, that two variables commute.
Todo
- Coercion doesn’t work yet, there is some cheating about assumptions
- The optional argument
check
controls checking the degeneracy conditions. Furthermore, the default values interfere with non-degeneracy conditions.
EXAMPLES:
sage: A.<x,y,z> = FreeAlgebra(QQ,3) sage: G = A.g_algebra({y*x: -x*y}) sage: (x,y,z) = G.gens() sage: x*y x*y sage: y*x -x*y sage: z*x x*z sage: (x,y,z) = A.gens() sage: G = A.g_algebra({y*x: -x*y+1}) sage: (x,y,z) = G.gens() sage: y*x -x*y + 1 sage: (x,y,z) = A.gens() sage: G = A.g_algebra({y*x: -x*y+z}) sage: (x,y,z) = G.gens() sage: y*x -x*y + z
-
gen
(i)¶ The
i
-th generator of the algebra.EXAMPLES:
sage: F = FreeAlgebra(ZZ,3,'x,y,z') sage: F.gen(0) x
-
gens
()¶ Return the generators of
self
.EXAMPLES:
sage: F = FreeAlgebra(ZZ,3,'x,y,z') sage: F.gens() (x, y, z)
-
is_commutative
()¶ Return True if this free algebra is commutative.
EXAMPLES:
sage: R.<x> = FreeAlgebra(QQ,1) sage: R.is_commutative() True sage: R.<x,y> = FreeAlgebra(QQ,2) sage: R.is_commutative() False
-
is_field
(proof=True)¶ Return True if this Free Algebra is a field, which is only if the base ring is a field and there are no generators
EXAMPLES:
sage: A = FreeAlgebra(QQ,0,'') sage: A.is_field() True sage: A = FreeAlgebra(QQ,1,'x') sage: A.is_field() False
-
lie_polynomial
(w)¶ Return the Lie polynomial associated to the Lyndon word
w
. Ifw
is not Lyndon, then return the product of Lie polynomials of the Lyndon factorization ofw
.INPUT:
w
– a word or an element of the free monoid
EXAMPLES:
sage: F = FreeAlgebra(QQ, 3, 'x,y,z') sage: M.<x,y,z> = FreeMonoid(3) sage: F.lie_polynomial(x*y) x*y - y*x sage: F.lie_polynomial(y*x) y*x sage: F.lie_polynomial(x^2*y*x) x^2*y*x - x*y*x^2 sage: F.lie_polynomial(y*z*x*z*x*z) y*z*x*z*x*z - y*z*x*z^2*x - y*z^2*x^2*z + y*z^2*x*z*x - z*y*x*z*x*z + z*y*x*z^2*x + z*y*z*x^2*z - z*y*z*x*z*x
TESTS:
We test some corner cases and alternative inputs:
sage: F.lie_polynomial(Word('xy')) x*y - y*x sage: F.lie_polynomial('xy') x*y - y*x sage: F.lie_polynomial(M.one()) 1 sage: F.lie_polynomial(Word([])) 1 sage: F.lie_polynomial('') 1
-
monoid
()¶ The free monoid of generators of the algebra.
EXAMPLES:
sage: F = FreeAlgebra(ZZ,3,'x,y,z') sage: F.monoid() Free monoid on 3 generators (x, y, z)
-
ngens
()¶ The number of generators of the algebra.
EXAMPLES:
sage: F = FreeAlgebra(ZZ,3,'x,y,z') sage: F.ngens() 3
-
one_basis
()¶ Return the index of the basis element \(1\).
EXAMPLES:
sage: F = FreeAlgebra(QQ, 2, 'x,y') sage: F.one_basis() 1 sage: F.one_basis().parent() Free monoid on 2 generators (x, y)
-
pbw_basis
()¶ Return the Poincare-Birkhoff-Witt (PBW) basis of
self
.EXAMPLES:
sage: F.<x,y> = FreeAlgebra(QQ, 2) sage: F.poincare_birkhoff_witt_basis() The Poincare-Birkhoff-Witt basis of Free Algebra on 2 generators (x, y) over Rational Field
-
pbw_element
(elt)¶ Return the element
elt
in the Poincare-Birkhoff-Witt basis.EXAMPLES:
sage: F.<x,y> = FreeAlgebra(QQ, 2) sage: F.pbw_element(x*y - y*x + 2) 2*PBW[1] + PBW[x*y] sage: F.pbw_element(F.one()) PBW[1] sage: F.pbw_element(x*y*x + x^3*y) PBW[x*y]*PBW[x] + PBW[y]*PBW[x]^2 + PBW[x^3*y] + PBW[x^2*y]*PBW[x] + PBW[x*y]*PBW[x]^2 + PBW[y]*PBW[x]^3
-
poincare_birkhoff_witt_basis
()¶ Return the Poincare-Birkhoff-Witt (PBW) basis of
self
.EXAMPLES:
sage: F.<x,y> = FreeAlgebra(QQ, 2) sage: F.poincare_birkhoff_witt_basis() The Poincare-Birkhoff-Witt basis of Free Algebra on 2 generators (x, y) over Rational Field
-
product_on_basis
(x, y)¶ Return the product of the basis elements indexed by
x
andy
.EXAMPLES:
sage: F = FreeAlgebra(ZZ,3,'x,y,z') sage: I = F.basis().keys() sage: x,y,z = I.gens() sage: F.product_on_basis(x*y, z*y) x*y*z*y
-
quo
(mons, mats=None, names=None)¶ Return a quotient algebra.
The quotient algebra is defined via the action of a free algebra \(A\) on a (finitely generated) free module. The input for the quotient algebra is a list of monomials (in the underlying monoid for \(A\)) which form a free basis for the module of \(A\), and a list of matrices, which give the action of the free generators of \(A\) on this monomial basis.
EXAMPLES:
Here is the quaternion algebra defined in terms of three generators:
sage: n = 3 sage: A = FreeAlgebra(QQ,n,'i') sage: F = A.monoid() sage: i, j, k = F.gens() sage: mons = [ F(1), i, j, k ] sage: M = MatrixSpace(QQ,4) sage: mats = [M([0,1,0,0, -1,0,0,0, 0,0,0,-1, 0,0,1,0]), M([0,0,1,0, 0,0,0,1, -1,0,0,0, 0,-1,0,0]), M([0,0,0,1, 0,0,-1,0, 0,1,0,0, -1,0,0,0]) ] sage: H.<i,j,k> = A.quotient(mons, mats); H Free algebra quotient on 3 generators ('i', 'j', 'k') and dimension 4 over Rational Field
-
quotient
(mons, mats=None, names=None)¶ Return a quotient algebra.
The quotient algebra is defined via the action of a free algebra \(A\) on a (finitely generated) free module. The input for the quotient algebra is a list of monomials (in the underlying monoid for \(A\)) which form a free basis for the module of \(A\), and a list of matrices, which give the action of the free generators of \(A\) on this monomial basis.
EXAMPLES:
Here is the quaternion algebra defined in terms of three generators:
sage: n = 3 sage: A = FreeAlgebra(QQ,n,'i') sage: F = A.monoid() sage: i, j, k = F.gens() sage: mons = [ F(1), i, j, k ] sage: M = MatrixSpace(QQ,4) sage: mats = [M([0,1,0,0, -1,0,0,0, 0,0,0,-1, 0,0,1,0]), M([0,0,1,0, 0,0,0,1, -1,0,0,0, 0,-1,0,0]), M([0,0,0,1, 0,0,-1,0, 0,1,0,0, -1,0,0,0]) ] sage: H.<i,j,k> = A.quotient(mons, mats); H Free algebra quotient on 3 generators ('i', 'j', 'k') and dimension 4 over Rational Field
-
class
sage.algebras.free_algebra.
PBWBasisOfFreeAlgebra
(alg)¶ Bases:
sage.combinat.free_module.CombinatorialFreeModule
The Poincare-Birkhoff-Witt basis of the free algebra.
EXAMPLES:
sage: F.<x,y> = FreeAlgebra(QQ, 2) sage: PBW = F.pbw_basis() sage: px, py = PBW.gens() sage: px * py PBW[x*y] + PBW[y]*PBW[x] sage: py * px PBW[y]*PBW[x] sage: px * py^3 * px - 2*px * py -2*PBW[x*y] - 2*PBW[y]*PBW[x] + PBW[x*y^3]*PBW[x] + PBW[y]*PBW[x*y^2]*PBW[x] + PBW[y]^2*PBW[x*y]*PBW[x] + PBW[y]^3*PBW[x]^2
We can convert between the two bases:
sage: p = PBW(x*y - y*x + 2); p 2*PBW[1] + PBW[x*y] sage: F(p) 2 + x*y - y*x sage: f = F.pbw_element(x*y*x + x^3*y + x + 3) sage: F(PBW(f)) == f True sage: p = px*py + py^4*px^2 sage: F(p) x*y + y^4*x^2 sage: PBW(F(p)) == p True
Note that multiplication in the PBW basis agrees with multiplication as monomials:
sage: F(px * py^3 * px - 2*px * py) == x*y^3*x - 2*x*y True
TESTS:
Check that going between the two bases is the identity:
sage: F = FreeAlgebra(QQ, 2, 'x,y') sage: PBW = F.pbw_basis() sage: M = F.monoid() sage: L = [j.to_monoid_element() for i in range(6) for j in Words('xy', i)] sage: all(PBW(F(PBW(m))) == PBW(m) for m in L) True sage: all(F(PBW(F(m))) == F(m) for m in L) True
-
class
Element
(M, x)¶ Bases:
sage.combinat.free_module.CombinatorialFreeModuleElement
Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s
__call__()
method.TESTS:
sage: F = CombinatorialFreeModule(QQ, ['a','b','c']) sage: B = F.basis() sage: f = B['a'] + 3*B['c']; f B['a'] + 3*B['c'] sage: f == loads(dumps(f)) True
-
expand
()¶ Expand
self
in the monomials of the free algebra.EXAMPLES:
sage: F = FreeAlgebra(QQ, 2, 'x,y') sage: PBW = F.pbw_basis() sage: x,y = F.monoid().gens() sage: f = PBW(x^2*y) + PBW(x) + PBW(y^4*x) sage: f.expand() x + x^2*y - x*y*x + y^4*x
-
-
PBWBasisOfFreeAlgebra.
algebra_generators
()¶ Return the generators of
self
as an algebra.EXAMPLES:
sage: PBW = FreeAlgebra(QQ, 2, 'x,y').pbw_basis() sage: gens = PBW.algebra_generators(); gens (PBW[x], PBW[y]) sage: all(g.parent() is PBW for g in gens) True
-
PBWBasisOfFreeAlgebra.
expansion
(t)¶ Return the expansion of the element
t
of the Poincare-Birkhoff-Witt basis in the monomials of the free algebra.EXAMPLES:
sage: F = FreeAlgebra(QQ, 2, 'x,y') sage: PBW = F.pbw_basis() sage: x,y = F.monoid().gens() sage: PBW.expansion(PBW(x*y)) x*y - y*x sage: PBW.expansion(PBW.one()) 1 sage: PBW.expansion(PBW(x*y*x) + 2*PBW(x) + 3) 3 + 2*x + x*y*x - y*x^2
TESTS:
Check that we have the correct parent:
sage: PBW.expansion(PBW(x*y)).parent() is F True sage: PBW.expansion(PBW.one()).parent() is F True
-
PBWBasisOfFreeAlgebra.
free_algebra
()¶ Return the associated free algebra of
self
.EXAMPLES:
sage: PBW = FreeAlgebra(QQ, 2, 'x,y').pbw_basis() sage: PBW.free_algebra() Free Algebra on 2 generators (x, y) over Rational Field
-
PBWBasisOfFreeAlgebra.
gen
(i)¶ Return the
i
-th generator ofself
.EXAMPLES:
sage: PBW = FreeAlgebra(QQ, 2, 'x,y').pbw_basis() sage: PBW.gen(0) PBW[x] sage: PBW.gen(1) PBW[y]
-
PBWBasisOfFreeAlgebra.
gens
()¶ Return the generators of
self
as an algebra.EXAMPLES:
sage: PBW = FreeAlgebra(QQ, 2, 'x,y').pbw_basis() sage: gens = PBW.algebra_generators(); gens (PBW[x], PBW[y]) sage: all(g.parent() is PBW for g in gens) True
-
PBWBasisOfFreeAlgebra.
one_basis
()¶ Return the index of the basis element for \(1\).
EXAMPLES:
sage: PBW = FreeAlgebra(QQ, 2, 'x,y').pbw_basis() sage: PBW.one_basis() 1 sage: PBW.one_basis().parent() Free monoid on 2 generators (x, y)
-
PBWBasisOfFreeAlgebra.
product
(u, v)¶ Return the product of two elements
u
andv
.EXAMPLES:
sage: F = FreeAlgebra(QQ, 2, 'x,y') sage: PBW = F.pbw_basis() sage: x, y = PBW.gens() sage: PBW.product(x, y) PBW[x*y] + PBW[y]*PBW[x] sage: PBW.product(y, x) PBW[y]*PBW[x] sage: PBW.product(y^2*x, x*y*x) PBW[y]^2*PBW[x^2*y]*PBW[x] + PBW[y]^2*PBW[x*y]*PBW[x]^2 + PBW[y]^3*PBW[x]^3
TESTS:
Check that multiplication agrees with the multiplication in the free algebra:
sage: F = FreeAlgebra(QQ, 2, 'x,y') sage: PBW = F.pbw_basis() sage: x, y = PBW.gens() sage: F(x*y) x*y sage: F(x*y*x) x*y*x sage: PBW(F(x)*F(y)*F(x)) == x*y*x True
-
class
-
sage.algebras.free_algebra.
is_FreeAlgebra
(x)¶ Return True if x is a free algebra; otherwise, return False.
EXAMPLES:
sage: from sage.algebras.free_algebra import is_FreeAlgebra sage: is_FreeAlgebra(5) False sage: is_FreeAlgebra(ZZ) False sage: is_FreeAlgebra(FreeAlgebra(ZZ,100,'x')) True sage: is_FreeAlgebra(FreeAlgebra(ZZ,10,'x',implementation='letterplace')) True sage: is_FreeAlgebra(FreeAlgebra(ZZ,10,'x',implementation='letterplace', degrees=list(range(1,11)))) True