Free Zinbiel Algebras¶
AUTHORS:
Travis Scrimshaw (2015-09): initial version
-
class
sage.algebras.free_zinbiel_algebra.
FreeZinbielAlgebra
(R, n, names, prefix, side)¶ Bases:
sage.combinat.free_module.CombinatorialFreeModule
The free Zinbiel algebra on \(n\) generators.
Let \(R\) be a ring. A Zinbiel algebra is a non-associative algebra with multiplication \(\circ\) that satisfies
\[(a \circ b) \circ c = a \circ (b \circ c) + a \circ (c \circ b).\]Zinbiel algebras were first introduced by Loday (see [Lod1995] and [LV2012]) as the Koszul dual to Leibniz algebras (hence the name coined by Lemaire).
By default, the convention above is used. The opposite product, which satisfy the opposite axiom, can be used instead by setting the
side
parameter to'>'
instead of the default value'<'
.Zinbiel algebras are divided power algebras, in that for
\[x^{\circ n} = \bigl(x \circ (x \circ \cdots \circ( x \circ x) \cdots ) \bigr)\]we have
\[x^{\circ m} \circ x^{\circ n} = \binom{n+m-1}{m} x^{n+m}\]and
\[\underbrace{\bigl( ( x \circ \cdots \circ x \circ (x \circ x) \cdots ) \bigr)}_{n+1 \text{ times}} = n! x^n.\]Note
This implies that Zinbiel algebras are not power associative.
To every Zinbiel algebra, we can construct a corresponding commutative associative algebra by using the symmetrized product:
\[a * b = a \circ b + b \circ a.\]The free Zinbiel algebra on \(n\) generators is isomorphic as \(R\)-modules to the reduced tensor algebra \(\bar{T}(R^n)\) with the product
\[(x_0 x_1 \cdots x_p) \circ (x_{p+1} x_{p+2} \cdots x_{p+q}) = \sum_{\sigma \in S_{p,q}} x_0 (x_{\sigma(1)} x_{\sigma(2)} \cdots x_{\sigma(p+q)},\]where \(S_{p,q}\) is the set of \((p,q)\)-shuffles.
The free Zinbiel algebra is free as a divided power algebra. Moreover, the corresponding commutative algebra is isomorphic to the (non-unital) shuffle algebra.
INPUT:
R
– a ringn
– (optional) the number of generatorsnames
– the generator names
Warning
Currently the basis is indexed by all finite words over the variables, including the empty word. This is a slight abuse as it is supposed to be indexed by all non-empty words.
EXAMPLES:
We create the free Zinbiel algebra and check the defining relation:
sage: Z.<x,y,z> = algebras.FreeZinbiel(QQ) sage: (x*y)*z Z[xyz] + Z[xzy] sage: x*(y*z) + x*(z*y) Z[xyz] + Z[xzy]
We see that the Zinbiel algebra is not associative, not even power associative:
sage: x*(y*z) Z[xyz] sage: x*(x*x) Z[xxx] sage: (x*x)*x 2*Z[xxx]
We verify that it is a divided power algebra:
sage: (x*(x*x)) * (x*(x*(x*x))) 15*Z[xxxxxxx] sage: binomial(3+4-1,4) 15 sage: (x*(x*(x*x))) * (x*(x*x)) 20*Z[xxxxxxx] sage: binomial(3+4-1,3) 20 sage: ((x*x)*x)*x 6*Z[xxxx] sage: (((x*x)*x)*x)*x 24*Z[xxxxx]
A few tests with the opposite convention for the product:
sage: Z.<x,y,z> = algebras.FreeZinbiel(QQ, side='>') sage: (x*y)*z Z[xyz] sage: x*(y*z) Z[xyz] + Z[yxz]
REFERENCES:
-
algebra_generators
()¶ Return the algebra generators of
self
.EXAMPLES:
sage: Z.<x,y,z> = algebras.FreeZinbiel(QQ) sage: list(Z.algebra_generators()) [Z[x], Z[y], Z[z]]
-
change_ring
(R)¶ Return the free Zinbiel algebra in the same variables over
R
.INPUT:
R
– a ring
The same side convention is used for the product.
EXAMPLES:
sage: A = algebras.FreeZinbiel(ZZ, 'f,g,h') sage: A.change_ring(QQ) Free Zinbiel algebra on generators (Z[f], Z[g], Z[h]) over Rational Field
-
construction
()¶ Return a pair
(F, R)
, whereF
is aZinbielFunctor
andR
is a ring, such thatF(R)
returnsself
.EXAMPLES:
sage: P = algebras.FreeZinbiel(ZZ, 'x,y') sage: x,y = P.gens() sage: F, R = P.construction() sage: F Zinbiel[x,y] sage: R Integer Ring sage: F(ZZ) is P True sage: F(QQ) Free Zinbiel algebra on generators (Z[x], Z[y]) over Rational Field
-
coproduct_on_basis
(w)¶ Return the coproduct of the element of the basis indexed by the word
w
.The coproduct is given by deconcatenation.
INPUT:
w
– a word
EXAMPLES:
sage: F = algebras.FreeZinbiel(QQ,['a','b']) sage: F.coproduct_on_basis(Word('a')) Z[] # Z[a] + Z[a] # Z[] sage: F.coproduct_on_basis(Word('aba')) Z[] # Z[aba] + Z[a] # Z[ba] + Z[ab] # Z[a] + Z[aba] # Z[] sage: F.coproduct_on_basis(Word()) Z[] # Z[]
-
counit
(S)¶ Return the counit of
S
.EXAMPLES:
sage: F = algebras.FreeZinbiel(QQ,['a','b']) sage: S = F.an_element(); S Z[] + 2*Z[a] + 3*Z[b] + Z[bab] sage: F.counit(S) 1
-
degree_on_basis
(t)¶ Return the degree of a word in the free Zinbiel algebra.
This is the length.
EXAMPLES:
sage: A = algebras.FreeZinbiel(QQ, 'x,y') sage: W = A.basis().keys() sage: A.degree_on_basis(W('xy')) 2
-
gens
()¶ Return the generators of
self
.EXAMPLES:
sage: Z.<x,y,z> = algebras.FreeZinbiel(QQ) sage: Z.gens() (Z[x], Z[y], Z[z])
-
product_on_basis_left
(x, y)¶ Return the product < of the basis elements indexed by
x
andy
.This is one half of the shuffle product, where the first letter comes from the first letter of the first argument.
INPUT:
x
,y
– two words
EXAMPLES:
sage: Z.<x,y,z> = algebras.FreeZinbiel(QQ) sage: (x*y)*z # indirect doctest Z[xyz] + Z[xzy]
-
product_on_basis_right
(x, y)¶ Return the product > of the basis elements indexed by
x
andy
.This is one half of the shuffle product, where the last letter comes from the last letter of the second argument.
INPUT:
x
,y
– two words
EXAMPLES:
sage: Z.<x,y,z> = algebras.FreeZinbiel(QQ, side='>') sage: (x*y)*z # indirect doctest Z[xyz]
-
side
()¶ Return the choice of side for the product.
This is either
'<'
or'>'
.EXAMPLES:
sage: Z.<x,y,z> = algebras.FreeZinbiel(QQ) sage: Z.side() '<'
-
class
sage.algebras.free_zinbiel_algebra.
ZinbielFunctor
(variables, side)¶ Bases:
sage.categories.pushout.ConstructionFunctor
A constructor for free Zinbiel algebras.
EXAMPLES:
sage: P = algebras.FreeZinbiel(ZZ, 'x,y') sage: x,y = P.gens() sage: F = P.construction()[0]; F Zinbiel[x,y] sage: A = GF(5)['a,b'] sage: a, b = A.gens() sage: F(A) Free Zinbiel algebra on generators (Z[x], Z[y]) over Multivariate Polynomial Ring in a, b over Finite Field of size 5 sage: f = A.hom([a+b,a-b],A) sage: F(f) Generic endomorphism of Free Zinbiel algebra on generators (Z[x], Z[y]) over Multivariate Polynomial Ring in a, b over Finite Field of size 5 sage: F(f)(a * F(A)(x)) (a+b)*Z[x]
-
merge
(other)¶ Merge
self
with another construction functor, or returnNone
.EXAMPLES:
sage: functor = sage.algebras.free_zinbiel_algebra.ZinbielFunctor sage: F = functor(['x','y'], '<') sage: G = functor(['t'], '<') sage: F.merge(G) Zinbiel[x,y,t] sage: F.merge(F) Zinbiel[x,y]
With an infinite generating set:
sage: H = functor(ZZ, '<') sage: H.merge(H) is H True sage: H.merge(F) is None True sage: F.merge(H) is None True
Now some actual use cases:
sage: R = algebras.FreeZinbiel(ZZ, 'x,y,z') sage: x,y,z = R.gens() sage: 1/2 * x 1/2*Z[x] sage: parent(1/2 * x) Free Zinbiel algebra on generators (Z[x], Z[y], Z[z]) over Rational Field sage: S = algebras.FreeZinbiel(QQ, 'z,t') sage: z,t = S.gens() sage: x * t Z[xt] sage: parent(x * t) Free Zinbiel algebra on generators (Z[z], Z[t], Z[x], Z[y]) over Rational Field
-