Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 Ind

### 1 Examples

#### 1.1 The natural numbers as a f.g. monoid

Create a right quiver $$q$$ with a single vertix $$o$$ and a single arrow $$m$$.

gap> q := RightQuiver( "q(o)[m:o->o]" );
q(o)[m:o->o]
gap> o := q.o;
(o)
gap> m := q.m;
(m)


Create a monoid from $$q$$.

gap> N := FreeCategory( q );
FreeCategory( RightQuiver( "q(o)[m:o->o]" ) )
gap> IsCommutative( N );
true
gap> N.o;
<(o)>
gap> N.m;
(o)-[(m)]->(o)
gap> SetOfObjects( N );
[ <(o)> ]
gap> SetOfGeneratingMorphisms( N );
[ (o)-[(m)]->(o) ]
gap> SetOfGeneratingMorphisms( N, N.o, N.o );
[ (o)-[(m)]->(o) ]
gap> ObjectInFpCategory( N, o ) = N.o;
true
gap> N.o = o / N;
true
gap> IdentityMorphism( N.o );
(o)-[(o)]->(o)
gap> MorphismInFpCategory( N, m ) = N.m;
true
gap> N.m = m / N;
true


We can compute in the algebroids. For instance we can form compositions.

gap> PreCompose( N.m, N.m );
(o)-[(m*m)]->(o)
gap> unit := Unit( N );
Functor from FreeCategory( RightQuiver( "*(1)[]" ) ) ->
FreeCategory( RightQuiver( "q(o)[m:o->o]" ) )
gap> mul := Multiplication( N );
Functor from
FreeCategory( RightQuiver( "qxq(oo)[om:oo->oo,mo:oo->oo]" ) ) / relations ->
FreeCategory( RightQuiver( "q(o)[m:o->o]" ) )


#### 1.2 The integers as f.g. monoid

Create a right quiver $$q$$ with a single vertix $$o$$ and two arrows $$m$$, $$i$$.

gap> q := RightQuiver( "q(o)[m:o->o,i:o->o]" );
q(o)[m:o->o,i:o->o]
gap> o := q.o;
(o)
gap> m := q.m;
(m)
gap> i := q.i;
(i)
gap> L := [ [ m * i, o ], [ i * m, o ] ];
[ [ (m*i), (o) ], [ (i*m), (o) ] ]


Create a monoid from $$q$$ and the list $$L$$ of relations.

gap> zz := Category( q, L );
FreeCategory( RightQuiver( "q(o)[m:o->o,i:o->o]" ) ) / [ m*i = o, i*m = o ]
gap> IsCommutative( zz );
true
gap> zz.o;
<(o)>
gap> IsWellDefined( zz.o );
true
gap> m := zz.m;
(o)-[(m)]->(o)
gap> i := zz.i;
(o)-[(i)]->(o)
gap> SetOfObjects( zz );
[ <(o)> ]
gap> SetOfGeneratingMorphisms( zz );
[ (o)-[(m)]->(o), (o)-[(i)]->(o) ]
gap> SetOfGeneratingMorphisms( zz, zz.o, zz.o );
[ (o)-[(m)]->(o), (o)-[(i)]->(o) ]
gap> ObjectInFpCategory( zz, o ) = zz.o;
true
gap> zz.o = o / zz;
true
gap> IdentityMorphism( zz.o );
(o)-[(o)]->(o)
gap> MorphismInFpCategory( zz, q.m ) = zz.m;
true
gap> zz.m = q.m / zz;
true


We can compute in the algebroids. For instance we can form compositions.

gap> m2 := PreCompose( [ m, i, m, m, i, m, i, m ] );
(o)-[(m*m)]->(o)
gap> IsWellDefined( m2 );
true
gap> unit := Unit( zz );
Functor from FreeCategory( RightQuiver( "*(1)[]" ) ) ->
FreeCategory( RightQuiver( "q(o)[m:o->o,i:o->o]" ) ) / [ m*i = o, i*m = o ]
gap> mul := Multiplication( zz );
Functor from
FreeCategory( RightQuiver(
"qxq(oo)[om:oo->oo,oi:oo->oo,mo:oo->oo,io:oo->oo]" ) ) / relations ->
FreeCategory( RightQuiver( "q(o)[m:o->o,i:o->o]" ) ) / [ m*i = o, i*m = o ]


#### 1.3 A f.p. category

Create a left quiver $$ql$$ with 3 vertices u,v,w and 4 edges a,b,c,d.

gap> ql := LeftQuiver( "ql(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]" );
ql(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]


Create a right quiver $$qr$$ with 3 vertices u,v,w and 4 edges a,b,c,d.

gap> qr := RightQuiver( "qr(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]" );
qr(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]


Create f.p. categories from these quivers.

gap> Cl := FreeCategory( ql );
FreeCategory( LeftQuiver( "ql(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]" ) )
gap> Cr := FreeCategory( qr );
FreeCategory( RightQuiver( "qr(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]" ) )
gap> Cl.u;
<(u)>
gap> Cr.u;
<(u)>
gap> Cl.a;
(v)<-[(a)]-(u)
gap> Cr.a;
(u)-[(a)]->(v)
gap> SetOfObjects( Cl );
[ <(u)>, <(v)>, <(w)> ]
gap> SetOfGeneratingMorphisms( Cl );
[ (v)<-[(a)]-(u), (u)<-[(b)]-(v), (u)<-[(c)]-(v), (w)<-[(d)]-(v) ]
gap> SetOfGeneratingMorphisms( Cl, Cl.u, Cl.v );
[ (v)<-[(a)]-(u) ]
gap> SetOfObjects( Cr );
[ <(u)>, <(v)>, <(w)> ]
gap> SetOfGeneratingMorphisms( Cr );
[ (u)-[(a)]->(v), (v)-[(b)]->(u), (v)-[(c)]->(u), (v)-[(d)]->(w) ]
gap> SetOfGeneratingMorphisms( Cr, Cr.u, Cr.v );
[ (u)-[(a)]->(v) ]
gap> ObjectInFpCategory( Cl, ql.u ) = Cl.u;
true
gap> Cl.u = ql.u / Cl;
true
gap> MorphismInFpCategory( Cl, ql.a ) = Cl.a;
true
gap> Cl.a = ql.a / Cl;
true
gap> IdentityMorphism( Cl.u );
(u)<-[(u)]-(u)
gap> IdentityMorphism( Cr.u );
(u)-[(u)]->(u)


We can compute in the algebroids. For instance we can form compositions.

gap> PreCompose( Cl.a, Cl.d );
(w)<-[(d*a)]-(u)
gap> PreCompose( Cr.a, Cr.d );
(u)-[(a*d)]->(w)


We can construct quotient categories

gap> q:= RightQuiver( "q(1)[a:1->1]" );
q(1)[a:1->1]
gap> Fq := FreeCategory( q );
FreeCategory( RightQuiver( "q(1)[a:1->1]" ) )
gap> C := Fq / [ [ Fq.a^3, Fq.a^2 ] ];
FreeCategory( RightQuiver( "q(1)[a:1->1]" ) ) / [ a*a*a = a*a ]
gap> UnderlyingQuiverAlgebra( C );
(Q * q) / [ 1*(a*a*a) - 1*(a*a) ]
gap> Size( C );
3
gap> D := C / [ [ C.a^9, C.1 ] ];
FreeCategory( RightQuiver( "q(1)[a:1->1]" ) ) /
[ a*a*a = a*a, a*a = 1 ]
gap> UnderlyingQuiverAlgebra( D );
(Q * q) / [ 1*(a) - 1*(1) ]
gap> Size( D );
1


#### 1.4 The full subcategory of the simplicial category truncated in degree 2

The full subcategory of the simplicial category $$\Delta$$ on the objects $$[0], [1], [2]$$

gap> LoadPackage( "Algebroids" );
true
gap> Delta2 := SimplicialCategoryTruncatedInDegree( 2 );
FreeCategory( RightQuiver(
"Delta(C0,C1,C2)[id:C1->C0,s:C0->C1,t:C0->C1,
is:C2->C1,it:C2->C1,
ps:C1->C2,pt:C1->C2,mu:C1->C2]" ) ) / relations
gap> RelationsOfFpCategory( Delta2 );
[ [ (s*id), (C0) ], [ (t*id), (C0) ],
[ (ps*is), (C1) ], [ (pt*it), (C1) ],
[ (is*id), (it*id) ], [ (pt*is), (id*t) ],
[ (ps*it), (id*s) ], [ (s*pt), (t*ps) ],
[ (s*mu), (s*ps) ], [ (t*mu), (t*pt) ],
[ (mu*is), (C1) ], [ (mu*it), (C1) ] ]
gap> Size( Delta2 );
31
gap> Delta2_op := OppositeFiniteCategory( Delta2 );
Opposite( FreeCategory( RightQuiver(
"Delta(C0,C1,C2)[id:C1->C0,s:C0->C1,t:C0->C1,
is:C2->C1,it:C2->C1,
ps:C1->C2,pt:C1->C2,mu:C1->C2]" ) ) / relations )
gap> IsIdenticalObj( OppositeFiniteCategory( Delta2_op ), Delta2 );
true


#### 1.5 Algebroids

Create a left quiver $$ql$$ with 3 vertices u,v,w and 4 edges a,b,c,d.

gap> ql := LeftQuiver( "ql(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]" );
ql(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]


Create a right quiver $$qr$$ with 3 vertices u,v,w and 4 edges a,b,c,d.

gap> qr := RightQuiver( "qr(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]" );
qr(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]


Create algebroids from these quivers over $$\mathbb{Q}$$.

gap> Q := HomalgFieldOfRationals( );
Q
gap> Al := Algebroid( Q, ql );
Algebroid( Q, FreeCategory(
LeftQuiver( "ql(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]" ) ) )
gap> algebra_Al := UnderlyingQuiverAlgebra( Al );
Q * ql
gap> Ar := Algebroid( Q, qr );
Algebroid( Q, FreeCategory(
RightQuiver( "qr(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]" ) ) )
gap> algebra_Ar := UnderlyingQuiverAlgebra( Ar );
Q * qr
gap> Al.u;
<(u)>
gap> Ar.u;
<(u)>
gap> Al.a;
(v)<-[1*(a)]-(u)
gap> Ar.a;
(u)-[1*(a)]->(v)
gap> SetOfObjects( Al );
[ <(u)>, <(v)>, <(w)> ]
gap> SetOfGeneratingMorphisms( Al );
[ (v)<-[1*(a)]-(u), (u)<-[1*(b)]-(v), (u)<-[1*(c)]-(v), (w)<-[1*(d)]-(v) ]
gap> SetOfGeneratingMorphisms( Al, Al.u, Al.v );
[ (v)<-[1*(a)]-(u) ]
gap> SetOfObjects( Ar );
[ <(u)>, <(v)>, <(w)> ]
gap> SetOfGeneratingMorphisms( Ar );
[ (u)-[1*(a)]->(v), (v)-[1*(b)]->(u), (v)-[1*(c)]->(u), (v)-[1*(d)]->(w) ]
gap> SetOfGeneratingMorphisms( Ar, Ar.u, Ar.v );
[ (u)-[1*(a)]->(v) ]
gap> CommutativeRingOfLinearCategory( Al ) = Q;
true
gap> ObjectInAlgebroid( Al, ql.u ) = Al.u;
true
gap> Al.u = ql.u / Al;
true
gap> MorphismInAlgebroid( Al, algebra_Al.a ) = Al.a;
true
gap> Al.a = algebra_Al.a / Al;
true
gap> IdentityMorphism( Al.u ) = algebra_Al.u / Al;
true


We can compute in the algebroids. For instance we can form compositions.

gap> PreCompose( Al.a, Al.d );
(w)<-[1*(d*a)]-(u)
gap> PreCompose( Ar.a, Ar.d );
(u)-[1*(a*d)]->(w)


We also have addition and subtraction of morphisms and scalar multiplication with elements from the ground ring $$\mathbb{Q}$$.

gap> Al.b+Al.c;
(u)<-[1*(c) + 1*(b)]-(v)
gap> Ar.b+Ar.c;
(v)-[1*(c) + 1*(b)]->(u)
gap> Al.b-Al.c;
(u)<-[-1*(c) + 1*(b)]-(v)
gap> Ar.b-Ar.c;
(v)-[-1*(c) + 1*(b)]->(u)
gap> Al.d - Al.d;
(w)<-[0]-(v)
gap> Ar.d - Ar.d;
(v)-[0]->(w)
gap> 1/2 * Al.d;
(w)<-[1/2*(d)]-(v)
gap> 1/2 * Ar.d;
(v)-[1/2*(d)]->(w)


We can construct quotient categories

gap> q:= RightQuiver( "q(1)[a:1->1]" );
q(1)[a:1->1]
gap> Fq := FreeCategory( q );
FreeCategory( RightQuiver( "q(1)[a:1->1]" ) )
gap> Q := HomalgFieldOfRationals( );
Q
gap> A := Q[Fq];
Algebra( Q, FreeCategory( RightQuiver( "q(1)[a:1->1]" ) ) )
gap> UnderlyingQuiverAlgebra( A );
Q * q
gap> B := A / [ 2*A.a^3 - A.a^2  ];
Algebra( Q, FreeCategory( RightQuiver( "q(1)[a:1->1]" ) ) ) / relations
gap> UnderlyingQuiverAlgebra( B );
(Q * q) / [ 2*(a*a*a) - 1*(a*a) ]
gap> Dimension( B );
3
gap> C := B / [ B.a^2 + 2*B.a ];
Algebra( Q, FreeCategory( RightQuiver( "q(1)[a:1->1]" ) ) ) / relations
gap> UnderlyingQuiverAlgebra( C );
(Q * q) / [ 2*(a*a*a) - 1*(a*a), 1*(a*a) + 2*(a) ]
gap> Dimension( C );
1


#### 1.6 Bialgebroids

Create a right quiver $$q$$ with two vertices $$u$$ and $$v$$ and two edges $$a$$ and $$b$$.

gap> q := RightQuiver( "q(u,v)[a:u->v,b:v->u]" );
q(u,v)[a:u->v,b:v->u]


Create the path algebra $$\mathbb{Q}q$$ of $$q$$ over $$\mathbb{Q}$$.

gap> q := RightQuiver( "q(u,v)[a:u->v,b:v->u]" );
q(u,v)[a:u->v,b:v->u]
gap> Q := HomalgFieldOfRationals( );
Q
gap> Qq := PathAlgebra( Q, q );
Q * q


Form a quotient of $$\mathbb{Q}q$$ by the relations $$ab - u$$ and $$ba - v$$.

gap> B := Algebroid( Qq, [ Qq.a * Qq.b - Qq.u, Qq.b * Qq.a - Qq.v ] );
Algebroid( Q, FreeCategory( RightQuiver( "q(u,v)[a:u->v,b:v->u]" ) ) )
/ relations
gap> RelationsOfAlgebroid( B );
[ (u)-[1*(a*b) - 1*(u)]->(u), (v)-[1*(b*a) - 1*(v)]->(v) ]

gap> IsCommutative(B);
false


Next we want to define a counit and a comultiplication on $$B$$ to make it a bialgebroid. The following record will be used to define the counit of $$B$$.

gap> counit := rec( a := 1, b := 1 );
rec( a := 1, b := 1 )


We compute the tensor product $$B \otimes_\mathbb{Q} B$$.

gap> B2 := B^2;
Algebroid( Q, FreeCategory( RightQuiver( "qxq(uu,uv,vu,vv)[\
ua:uu->uv,ub:uv->uu,va:vu->vv,vb:vv->vu,\
au:uu->vu,av:uv->vv,bu:vu->uu,bv:vv->uv]" ) ) ) / relations


The following record will be used to define the comultiplication $$B \to B \otimes_{\mathbb{Q}} B$$.

gap> comult:= rec( a := PreCompose(B2.au, B2.va), b:= PreCompose(B2.bv, B2.ub) );
rec( a := (uu)-[{ 1*(ua*av) }]->(vv), b := (vv)-[{ 1*(vb*bu) }]->(uu) )


We use the records counit and comult to equip $$B$$ with the induced morphisms $$B \to \mathbb{Q}$$ and $$B \to B \otimes_{\mathbb{Q}} B$$.

gap> AddBialgebroidStructure( B, counit, comult );
Bialgebroid( Q, FreeCategory( RightQuiver( "q(u,v)[a:u->v,b:v->u]" ) ) )
/ relations


We extract comultiplication and counit from $$B$$. They are now functors.

gap> counit := Counit( B );
Functor from Bialgebroid( Q, FreeCategory(
RightQuiver( "q(u,v)[a:u->v,b:v->u]" ) ) ) / relations
->
Algebra( Q, FreeCategory( RightQuiver( "*(1)[]" ) ) )
gap> comult := Comultiplication( B );
Functor from Bialgebroid( Q, FreeCategory(
RightQuiver( "q(u,v)[a:u->v,b:v->u]" ) ) ) / relations
->
Algebroid( Q, FreeCategory(
RightQuiver( "qxq(uu,uv,vu,vv)[ua:uu->uv,ub:uv->uu,va:vu->vv,vb:vv->vu,\
au:uu->vu,av:uv->vv,bu:vu->uu,bv:vv->uv]" ) ) ) / relations


Apply comultiplication and counit.

gap> ApplyFunctor( counit, B.u );
<(1)>
gap> ApplyFunctor( counit, B.v );
<(1)>
gap> ApplyFunctor( counit, IdentityMorphism( B.u ) );
(1)-[1*(1)]->(1)
gap> ApplyFunctor( counit, IdentityMorphism( B.v ) );
(1)-[1*(1)]->(1)
gap> ApplyFunctor( counit, B.a );
(1)-[1*(1)]->(1)
gap> ApplyFunctor( counit, B.b );
(1)-[1*(1)]->(1)
gap> ApplyFunctor( comult, B.u );
<(uu)>
gap> ApplyFunctor( comult, B.v );
<(vv)>
gap> ApplyFunctor( comult, IdentityMorphism( B.u ) );
(uu)-[{ 1*(uu) }]->(uu)
gap> ApplyFunctor( comult, IdentityMorphism( B.v ) );
(vv)-[{ 1*(vv) }]->(vv)
gap> ApplyFunctor( comult, B.a );
(uu)-[{ 1*(ua*av) }]->(vv)
gap> ApplyFunctor( comult, B.b );
(vv)-[{ 1*(vb*bu) }]->(uu)
gap> IsCoassociative(B);
true
gap> IsCocommutative(B);
true


#### 1.7 Hopf algebra generated by group-like elements

gap> q := RightQuiver( "q(1)[g:1->1,h:1->1]" );
q(1)[g:1->1,h:1->1]
gap> Q := HomalgFieldOfRationals( );
Q
gap> Qq := PathAlgebra( Q, q );
Q * q
gap> B := Algebroid( Qq, [ Qq.h * Qq.g - Qq.1, Qq.g * Qq.h - Qq.1 ] );
Algebra( Q, FreeCategory( RightQuiver( "q(1)[g:1->1,h:1->1]" ) ) )
/ relations
gap> B2 := B^2;
Algebra( Q, FreeCategory( RightQuiver(
"qxq(1x1)[1xg:1x1->1x1,1xh:1x1->1x1,gx1:1x1->1x1,hx1:1x1->1x1]" ) ) )
/ relations
gap> counit_rec := rec( g := 1, h := 1 );;
gap> comult_rec := rec( g := PreCompose( B2.1xg, B2.gx1 ),
>                    h := PreCompose( B2.1xh, B2.hx1 ) );;
gap> AddBialgebroidStructure( B, counit_rec, comult_rec );
Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[g:1->1,h:1->1]" ) ) )
/ relations
gap> counit := Counit( B );
Functor from
Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[g:1->1,h:1->1]" ) ) )
/ relations
->
Algebra( Q, FreeCategory( RightQuiver( "*(1)[]" ) ) )
gap> comult := Comultiplication( B );
Functor from
Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[g:1->1,h:1->1]" ) ) )
/ relations
->
Algebra( Q, FreeCategory( RightQuiver(
"qxq(1x1)[1xg:1x1->1x1,1xh:1x1->1x1,gx1:1x1->1x1,hx1:1x1->1x1]" ) ) )
/ relations
gap> antipode_rec := rec( g := B.h, h := B.g );;
gap> B;
HopfAlgebra( Q, FreeCategory( RightQuiver( "q(1)[g:1->1,h:1->1]" ) ) )
/ relations
gap> Antipode(B);
Contravariant functor from
HopfAlgebra( Q, FreeCategory( RightQuiver( "q(1)[g:1->1,h:1->1]" ) ) )
/ relations
->
HopfAlgebra( Q, Fr eeCategory( RightQuiver( "q(1)[g:1->1,h:1->1]" ) ) )
/ relations
gap> ApplyFunctor( counit, B.g );
(1)-[1*(1)]->(1)
gap> IsCommutative(B);
true
gap> IsCounitary(B);
true
gap> IsCocommutative(B);
true
gap> IsHopfAlgebroid(B);
true


#### 1.8 Hopf algebra generated by a primitive element

gap> # Hopf algebra generated by a primitive element
> q := RightQuiver( "q(1)[t:1->1]" );
q(1)[t:1->1]
gap> Q := HomalgFieldOfRationals( );
Q
gap> Qq := PathAlgebra( Q, q );
Q * q
gap> B := Algebroid( Qq );
Algebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
gap> Q = UnderlyingAlgebra( B );
true
gap> B2 := B^2;
Algebra( Q, FreeCategory(
RightQuiver( "qxq(1x1)[1xt:1x1->1x1,tx1:1x1->1x1]" ) ) ) / relations
gap> B0 := B^0;
Algebra( Q, FreeCategory( RightQuiver( "*(1)[]" ) ) )
gap> counit_rec := rec( t := 0 );;
gap> comult_rec := rec( t := B2.1xt + B2.tx1 );;
gap> AddBialgebroidStructure( B, counit_rec, comult_rec );
Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
gap> antipode_rec := rec( t:= -B.t );;
gap> counit := Counit( B );
Functor from Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
->
Algebra( Q, FreeCategory( RightQuiver( "*(1)[]" ) ) )
gap> comult := Comultiplication( B );
Functor from Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
->
Algebra( Q, FreeCategory(
RightQuiver( "qxq(1x1)[1xt:1x1->1x1,tx1:1x1->1x1]" ) ) ) / relations
gap> idB := IdentityFunctor( B );
Identity functor of Algebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
gap> ApplyFunctor( comult, B.t );
(1x1)-[{ 1*(tx1) + 1*(1xt) }]->(1x1)
gap> ApplyFunctor( counit, B.t );
(1)-[0]->(1)
gap> IsCommutative(B);
true
gap> IsCounitary(B);
true
gap> IsCocommutative(B);
true
gap> IsHopfAlgebroid(B);
true
gap> BB := CategoryOfAlgebroidsObject(B);;
gap> IsCoassociative( BB );
true
gap> IsCounitary( BB );
true


#### 1.9 A non-counitary coalgebra

gap> q := RightQuiver( "q(1)[t:1->1]" );
q(1)[t:1->1]
gap> Q := HomalgFieldOfRationals( );
Q
gap> Qq := PathAlgebra( Q, q );
Q * q
gap> B := Algebroid( Qq );
Algebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
gap> B2 := B^2;
Algebra( Q, FreeCategory(
RightQuiver( "qxq(1x1)[1xt:1x1->1x1,tx1:1x1->1x1]" ) ) ) / relations
gap> B0 := B^0;
Algebra( Q, FreeCategory( RightQuiver( "*(1)[]" ) ) )
gap> counit_rec := rec( t := 0 );;
gap> comult_rec := rec( t := B2.1xt );;
gap> AddBialgebroidStructure( B, counit_rec, comult_rec );
Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
gap> antipode_rec := rec( t:= -B.t );;
gap> counit := Counit( B );
Functor from Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
->
Algebra( Q, FreeCategory( RightQuiver( "*(1)[]" ) ) )
gap> comult := Comultiplication( B );
Functor from Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
->
Algebra( Q, FreeCategory(
RightQuiver( "qxq(1x1)[1xt:1x1->1x1,tx1:1x1->1x1]" ) ) ) / relations
gap> IsCommutative(B);
true
gap> IsCoassociative(B);
true
gap> IsCounitary(B);
false


#### 1.10 Sweedlers 4-dimensional Hopf algebra

gap> q := RightQuiver( "q(1)[x:1->1,g:1->1]" );
q(1)[x:1->1,g:1->1]
gap> Q := HomalgFieldOfRationals( );
Q
gap> Qq := PathAlgebra( Q, q );
Q * q
gap> H := Algebroid( Qq, [ Qq.g * Qq.g - Qq.1,
>                     Qq.x * Qq.x,
>                     Qq.x * Qq.g + Qq.g * Qq.x,
>                     ] );
Algebra( Q, FreeCategory( RightQuiver( "q(1)[x:1->1,g:1->1]" ) ) )
/ relations
gap> H2 := H^2;
Algebra( Q, FreeCategory( RightQuiver(
"qxq(1x1)[1xx:1x1->1x1,1xg:1x1->1x1,xx1:1x1->1x1,gx1:1x1->1x1]" ) ) )
/ relations
gap> counit_rec := rec( x := 0,
>                    g := 1
>                  );;
gap> comult_rec := rec( g := PreCompose(H2.gx1, H2.1xg),
>                    x := H2.1xx + PreCompose(H2.xx1, H2.1xg)
>                  );;
gap> AddBialgebroidStructure( H, counit_rec, comult_rec );
Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[x:1->1,g:1->1]" ) ) )
/ relations
gap> counit := Counit( H );
Functor from
Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[x:1->1,g:1->1]" ) ) )
/ relations
->
Algebra( Q, FreeCategory( RightQuiver( "*(1)[]" ) ) )
gap> comult := Comultiplication( H );
Functor from
Bialgebra( Q, FreeCategory( RightQuiver( "q(1)[x:1->1,g:1->1]" ) ) )
/ relations
->
Algebra( Q, FreeCategory( RightQuiver(
"qxq(1x1)[1xx:1x1->1x1,1xg:1x1->1x1,xx1:1x1->1x1,gx1:1x1->1x1]" ) ) )
/ relations
gap> antipode_rec := rec( g:= H.g,
>                      x := - PreCompose( H.x, H.g )
>                    );;
gap> antipode := Antipode( H );
Contravariant functor from
HopfAlgebra( Q, FreeCategory( RightQuiver( "q(1)[x:1->1,g:1->1]" ) ) )
/ relations
->
HopfAlgebra( Q, FreeCategory( RightQuiver( "q(1)[x:1->1,g:1->1]" ) ) )
/ relations
gap> IsCommutative(H);
false
gap> ApplyFunctor(antipode, H.g);
(1)-[{ 1*(g) }]->(1)
gap> ApplyFunctor(antipode, H.x);
(1)-[{ -1*(x*g) }]->(1)
gap> IsEqualForMorphisms(
>         ApplyFunctor( antipode, H.x ),
>         -PreCompose( H.x, H.g ) );
true


Verify that the antipode of $$H$$ has order 4.

gap> IsEqualForMorphisms( ApplyFunctor( antipode, H.g ), H.g );
true
gap> IsEqualForMorphisms( ApplyFunctor( antipode, H.x ), H.x );
false
gap> IsEqualForMorphisms( ApplyFunctor(
>     PreCompose( [ antipode, antipode ] ), H.x ), H.x );
false
gap> IsEqualForMorphisms( ApplyFunctor(
>     PreCompose( [ antipode, antipode, antipode ] ), H.x ), H.x );
false
gap> IsEqualForMorphisms( ApplyFunctor(
>     PreCompose( [ antipode, antipode, antipode, antipode ] ), H.x ), H.x );
true
gap> IsCocommutative(H);
false


#### 1.11 Homomorphism structure

We perform simple computations with the Homomorphism structure of the Beilison quiver of the projective space of dimension 3.

gap> q := RightQuiver( "q(4)[\
> x0:1->2,x1:1->2,x2:1->2,x3:1->2,\
> y0:2->3,y1:2->3,y2:2->3,y3:2->3,\
> z0:3->4,z1:3->4,z2:3->4,z3:3->4]" );;
gap> F := FreeCategory( q );;
gap> beilinson_P3 := F /
>                 [ [ PreCompose( F.x0, F.y1 ), PreCompose( F.x1, F.y0 ) ],
>                   [ PreCompose( F.x0, F.y2 ), PreCompose( F.x2, F.y0 ) ],
>                   [ PreCompose( F.x0, F.y3 ), PreCompose( F.x3, F.y0 ) ],
>                   [ PreCompose( F.x1, F.y2 ), PreCompose( F.x2, F.y1 ) ],
>                   [ PreCompose( F.x1, F.y3 ), PreCompose( F.x3, F.y1 ) ],
>                   [ PreCompose( F.x2, F.y3 ), PreCompose( F.x3, F.y2 ) ],
>                   [ PreCompose( F.y0, F.z1 ), PreCompose( F.y1, F.z0 ) ],
>                   [ PreCompose( F.y0, F.z2 ), PreCompose( F.y2, F.z0 ) ],
>                   [ PreCompose( F.y0, F.z3 ), PreCompose( F.y3, F.z0 ) ],
>                   [ PreCompose( F.y1, F.z2 ), PreCompose( F.y2, F.z1 ) ],
>                   [ PreCompose( F.y1, F.z3 ), PreCompose( F.y3, F.z1 ) ],
>                   [ PreCompose( F.y2, F.z3 ), PreCompose( F.y3, F.z2 ) ] ];;
gap> Q := HomalgFieldOfRationals( );;
gap> Beilinson_P3 := Q[beilinson_P3];;
gap> objs := SetOfObjects( Beilinson_P3 );;
gap> Length( objs ) = 4;
true
gap> maps := SetOfGeneratingMorphisms( Beilinson_P3.1, Beilinson_P3.2 );;
gap> maps = SetOfGeneratingMorphisms( Beilinson_P3, 1, 2 );
true
gap> Length( maps ) = 4;
true
gap> ForAll( [ 0 .. 3 ], k ->
>         RankOfObject( HomomorphismStructureOnObjects( objs[1], objs[1 + k] ) )
>         = Binomial( 4 + k - 1, k )
> );
true
gap> alpha := Beilinson_P3.x0;;
gap> beta := ( Beilinson_P3.z1 + Beilinson_P3.z2 );;
gap> gamma := PreCompose( [ alpha, (Beilinson_P3.y1 - Beilinson_P3.y3), beta ] );;
gap> sol := SolveLinearSystemInAbCategory(
>                [ [ alpha ] ], [ [ beta ] ], [ gamma ] )[1];;
gap> IsCongruentForMorphisms( PreCompose( [ alpha, sol, beta ] ), gamma );
true


#### 1.12 Algebroids over the integers

We create an algebroid over $$\mathbb{Q}$$ and its descent to $$\mathbb{Z}$$ defined by basis paths.

gap> q := RightQuiver( "q(4)[a:1->2,b:1->3,c:3->4,d:2->4]" );;
gap> Q := HomalgFieldOfRationals( );;
gap> Qq := PathAlgebra( Q, q );;
gap> Qq := Qq / [ Qq.a * Qq.d - Qq.b * Qq.c];;
gap> A_Q := Algebroid( Qq );;
gap> A_Z := DescentToZDefinedByBasisPaths( A_Q );;


We demonstrate the practical difference between the two algebroids by trying to solve one and the same linear system.

gap> alpha := 2 * A_Q.a;;
gap> id := IdentityMorphism( A_Q.4 );;
gap> gamma := PreCompose( A_Q.b, A_Q.c );;
gap> sol := SolveLinearSystemInAbCategory( [ [ alpha ] ], [ [ id ] ], [ gamma ] );
[ (2)-[{ 1/2*(d) }]->(4) ]


Thus, a solution exists over the rationals.

gap> alpha := 2 * A_Z.a;;
gap> id := IdentityMorphism( A_Z.4 );;
gap> gamma := PreCompose( A_Z.b, A_Z.c );;
gap> sol := MereExistenceOfSolutionOfLinearSystemInAbCategory(
>                [ [ alpha ] ], [ [ id ] ], [ gamma ] );
false


No solution exists over the integers.

#### 1.13 Unitors

gap> q := LeftQuiver( "ql(u,v,w)[a:u->v,b:v->u,c:v->u,d:v->w]" );;
gap> Q := HomalgFieldOfRationals( );;
gap> B := Algebroid( Q, q );;
gap> B0 := B^0;;
gap> lu := LeftUnitorAsFunctor(B);;
gap> ru := RightUnitorAsFunctor(B);;
gap> lui := LeftUnitorInverseAsFunctor(B);;
gap> rui := RightUnitorInverseAsFunctor(B);;
gap> AsCapCategory(Target(lu)) = B;
true
gap> AsCapCategory(Target(ru)) = B;
true
gap> AsCapCategory(Source(lu)) = TensorProductOnObjects( B0, B );
true
gap> AsCapCategory(Source(ru)) = TensorProductOnObjects( B, B0 );
true
gap> AsCapCategory(Source(lui)) = B;
true
gap> AsCapCategory(Source(rui)) = B;
true
gap> AsCapCategory(Target(lui)) = TensorProductOnObjects( B0, B );
true
gap> AsCapCategory(Target(rui)) = TensorProductOnObjects( B, B0 );
true
gap> l := Concatenation( [
>              List( SetOfObjects(B),
>                    o -> ApplyFunctor( PreCompose(lui, lu), o) = o and
>                    ApplyFunctor( PreCompose(rui, ru), o) = o ),
>              List( SetOfGeneratingMorphisms(B),
>                    m -> ApplyFunctor( PreCompose(lui, lu), m) = m and
>                    ApplyFunctor( PreCompose(rui, ru), m) = m ),
>              List( SetOfObjects(B^0 * B),
>                    o -> ApplyFunctor( PreCompose(lu, lui), o) = o ),
>              List( SetOfGeneratingMorphisms(B^0 * B),
>                    m -> ApplyFunctor( PreCompose(lu, lui), m) = m)
>  ] );;
gap> and_function := function(x,y) return x and y; end;;
gap> Iterated( l, and_function );
true
gap> # Consider B as an object in the category of algebroids over Q
> BB := CategoryOfAlgebroidsObject(B);;
gap> BB2 := TensorProductOnObjects(BB, BB);;
gap> BB0 := TensorUnit( CapCategory( BB ) );;
gap> ru_as_functor := RightUnitor( BB );;
gap> lu_as_functor := LeftUnitor( BB );;
gap> rui_as_functor := RightUnitorInverse( BB );;
gap> lui_as_functor := LeftUnitorInverse( BB );;
gap> IsCongruentForMorphisms( PreCompose( ru_as_functor, rui_as_functor ),
>         IdentityMorphism( TensorProductOnObjects( BB,  BB0 ) ) );
true
gap> IsCongruentForMorphisms( PreCompose( lu_as_functor, lui_as_functor ),
>         IdentityMorphism( TensorProductOnObjects( BB0,  BB ) ) );
true
gap> IsCongruentForMorphisms( PreCompose( rui_as_functor, ru_as_functor ),
>         IdentityMorphism( BB ) );
true
gap> IsCongruentForMorphisms( PreCompose( lui_as_functor, lu_as_functor ),
>         IdentityMorphism( BB ) );
true


#### 1.14 Associators

gap> q := RightQuiver( "q(1)[t:1->1]" );
q(1)[t:1->1]
gap> Q := HomalgFieldOfRationals( );
Q
gap> Qq := PathAlgebra( Q, q );
Q * q
gap> B := Algebroid( Qq );
Algebra( Q, FreeCategory( RightQuiver( "q(1)[t:1->1]" ) ) )
gap> ass_ltr := AssociatorLeftToRightWithGivenTensorProductsAsFunctor(
>                    (B*B)*B, B, B, B, B*(B*B) );;
gap> ass_rtl := AssociatorRightToLeftWithGivenTensorProductsAsFunctor(
>                    B*(B*B), B, B, B, (B*B)*B );;
gap> Source(ass_ltr) = Target(ass_rtl);
true
gap> Target(ass_ltr) = Source(ass_rtl);
true
gap> # Consider B as an object in the category of algebroids over Q
> BB := CategoryOfAlgebroidsObject(B);;
gap> BB2 := TensorProductOnObjects(BB, BB);;
gap> BB0 := TensorUnit( CapCategory( BB ) );;
gap> ass_ltr_as_morphism := AssociatorLeftToRight(BB,BB,BB);;
gap> ass_rtl_as_morphism := AssociatorRightToLeft(BB,BB,BB);;
gap> IsCongruentForMorphisms(
>         PreCompose( ass_ltr_as_morphism, ass_rtl_as_morphism ),
>         IdentityMorphism( Source( ass_ltr_as_morphism ) ) );
true
gap> IsCongruentForMorphisms(
>         PreCompose( ass_rtl_as_morphism, ass_ltr_as_morphism ),
>         IdentityMorphism( Source( ass_rtl_as_morphism ) ) );
true

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 Ind

generated by GAPDoc2HTML