Copy of LOOPS 3.3.0
This commit is contained in:
Glen Whitney
commit
7e8b3b5562
510 changed files with 97978 additions and 0 deletions
35
tst/bol.tst
Normal file
35
tst/bol.tst
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
#############################################################################
|
||||
##
|
||||
#W bol.tst Testing Bol loops G. P. Nagy / P. Vojtechovsky
|
||||
##
|
||||
#H @(#)$Id: iso.tst, v 3.0.0 2015/06/05 gap Exp $
|
||||
##
|
||||
#Y Copyright (C) 2004, G. P. Nagy (University of Szeged, Hungary),
|
||||
#Y P. Vojtechovsky (University of Denver, USA)
|
||||
##
|
||||
|
||||
gap> START_TEST("LOOPS, bol: testing methods for Bol loops");
|
||||
|
||||
# TESTING ASSOCIATED BRUCK LOOPS
|
||||
|
||||
gap> Q := LeftBolLoop(15,2);;
|
||||
gap> B := AssociatedLeftBruckLoop(Q);;
|
||||
gap> IsomorphismLoops(B,LeftBolLoop(15,1));
|
||||
(7,9,10,8)(12,13,15,14)
|
||||
|
||||
gap> Q := RightBolLoop(15,1);;
|
||||
gap> AssociatedRightBruckLoop( Q );
|
||||
<right Bol loop of order 15>
|
||||
|
||||
# TESTING EXACT GROUP FACTORIZATIONS
|
||||
|
||||
gap> G := SymmetricGroup( 5 );;
|
||||
gap> H1 := Subgroup( G, [(1,2),(1,3),(1,4)] );;
|
||||
gap> H2 := Subgroup(G,[(1,2,3,4,5)]);;
|
||||
gap> IsExactGroupFactorization(G,H1,H2);
|
||||
true
|
||||
gap> RightBolLoopByExactGroupFactorization(G,H1,H2); RightBolLoopByExactGroupFactorization([G,H1,H2]);
|
||||
<loop of order 120>
|
||||
<loop of order 120>
|
||||
|
||||
gap> STOP_TEST( "bol.tst", 10000000 );
|
||||
410
tst/core_methods.tst
Normal file
410
tst/core_methods.tst
Normal file
|
|
@ -0,0 +1,410 @@
|
|||
#############################################################################
|
||||
##
|
||||
#W core_methods.tst Testing core methods G. P. Nagy / P. Vojtechovsky
|
||||
##
|
||||
#H @(#)$Id: core_methods.tst, v 3.3.0 2016/10/26 gap Exp $
|
||||
##
|
||||
#Y Copyright (C) 2004, G. P. Nagy (University of Szeged, Hungary),
|
||||
#Y P. Vojtechovsky (University of Denver, USA)
|
||||
##
|
||||
|
||||
gap> START_TEST("LOOPS, core_methods: testing core methods");
|
||||
|
||||
# TESTING VIEW AND PRINT MODE, AND LATIN SQUARE FUNCTIONS
|
||||
|
||||
gap> T := [ [ 2, 1 ], [ 1, 2 ] ];;
|
||||
gap> IsQuasigroupTable( T );
|
||||
true
|
||||
gap> IsLoopTable( T );
|
||||
false
|
||||
gap> Q := QuasigroupByCayleyTable( T );
|
||||
<quasigroup of order 2>
|
||||
gap> Elements( Q );
|
||||
[ q1, q2 ]
|
||||
gap> L := IntoLoop( Q );
|
||||
<loop of order 2>
|
||||
gap> Elements( L );
|
||||
[ l1, l2 ]
|
||||
gap> L.1;
|
||||
l1
|
||||
|
||||
# TESTING MORE CONVERSION FUNCTIONS
|
||||
|
||||
gap> G := IntoGroup( Q );
|
||||
Group([ (), (1,2) ])
|
||||
gap> G := IntoGroup( L );
|
||||
Group([ (), (1,2) ])
|
||||
gap> IntoQuasigroup( G );
|
||||
<quasigroup of order 2>
|
||||
gap> IntoLoop( G );
|
||||
<loop of order 2>
|
||||
gap> IntoLoop( Group( (1,2,3), (1,2), (1,4) ) );
|
||||
<loop of order 24>
|
||||
gap> PrincipalLoopIsotope( Q, Elements(Q)[1], Elements(Q)[1] );
|
||||
<loop of order 2>
|
||||
gap> CanonicalCopy( QuasigroupByCayleyTable( [[2,3],[3,2]] ) );
|
||||
<quasigroup of order 2>
|
||||
|
||||
# TESTING DIRECT PRODUCTS AND OPPOSITES
|
||||
|
||||
gap> L := MoufangLoop( 12, 1 );;
|
||||
gap> DirectProduct( L );
|
||||
<Moufang loop 12/1>
|
||||
gap> DirectProduct( L, L, L );
|
||||
<loop of order 1728>
|
||||
gap> DirectProduct( L, Group( (1,2,3) ) );
|
||||
<loop of order 36>
|
||||
gap> DirectProduct( Group( (1,2,3) ), L, Group( (1,2,3,4) ) );
|
||||
<loop of order 144>
|
||||
gap> Q := QuasigroupByCayleyTable([[2,1],[1,2]]);;
|
||||
gap> DirectProduct( Q, Q );
|
||||
<quasigroup of order 4>
|
||||
gap> DirectProduct( Q, L, Group((1,2)) );
|
||||
<quasigroup of order 48>
|
||||
gap> OppositeLoop( L );
|
||||
<loop of order 12>
|
||||
|
||||
# TESTING BASIC ATTRIBUTES
|
||||
|
||||
gap> One( L );
|
||||
l1
|
||||
gap> Size( L );
|
||||
12
|
||||
gap> CayleyTable( Q );
|
||||
[ [ 2, 1 ], [ 1, 2 ] ]
|
||||
gap> Exponent( L );
|
||||
6
|
||||
gap> Opposite( L );
|
||||
<loop of order 12>
|
||||
|
||||
# TESTING BASIC ARITHMETIC OPERATIONS
|
||||
|
||||
gap> eL := Elements( L );;
|
||||
gap> eL[ 2 ]*eL[ 3 ]*eL[ 7 ] = (eL[ 2 ]*eL[ 3 ])* eL[ 7 ];
|
||||
true
|
||||
gap> eL[ 2 ]*eL[ 3 ]*eL[ 7 ] = eL[ 2 ]*(eL[ 3 ]* eL[ 7 ]);
|
||||
false
|
||||
gap> LeftDivision( eL[ 2 ], eL[ 3 ] );
|
||||
l4
|
||||
gap> RightDivision( eL[ 2 ], eL[ 3 ] );
|
||||
l6
|
||||
gap> LeftInverse( eL[ 2 ] ) = RightInverse( eL[ 2 ] );
|
||||
true
|
||||
gap> Associator( eL[ 2 ], eL[ 3 ], eL[ 4 ] );
|
||||
l1
|
||||
gap> Commutator( eL[ 2 ], eL[ 3 ] );
|
||||
l5
|
||||
|
||||
# TESTING GENERATORS
|
||||
|
||||
gap> GeneratorsOfLoop( L );
|
||||
[ l1, l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12 ]
|
||||
gap> GeneratorsSmallest( L );
|
||||
[ l10, l11, l12 ]
|
||||
gap> SmallGeneratingSet( L );
|
||||
[ l2, l3, l7 ]
|
||||
|
||||
# TESTING SECTIONS AND TRANSLATIONS
|
||||
|
||||
gap> LeftSection( L );
|
||||
[ (), (1,2)(3,4)(5,6)(7,8)(9,12)(10,11), (1,3,5)(2,6,4)(7,9,11)(8,10,12),
|
||||
(1,4)(2,5)(3,6)(7,10)(8,9)(11,12), (1,5,3)(2,4,6)(7,11,9)(8,12,10),
|
||||
(1,6)(2,3)(4,5)(7,12)(8,11)(9,10), (1,7)(2,8)(3,11)(4,10)(5,9)(6,12),
|
||||
(1,8)(2,7)(3,12)(4,9)(5,10)(6,11), (1,9)(2,12)(3,7)(4,8)(5,11)(6,10),
|
||||
(1,10)(2,11)(3,8)(4,7)(5,12)(6,9), (1,11)(2,10)(3,9)(4,12)(5,7)(6,8),
|
||||
(1,12)(2,9)(3,10)(4,11)(5,8)(6,7) ]
|
||||
gap> RightSection( L );
|
||||
[ (), (1,2)(3,6)(4,5)(7,8)(9,12)(10,11), (1,3,5)(2,4,6)(7,11,9)(8,12,10),
|
||||
(1,4)(2,3)(5,6)(7,10)(8,9)(11,12), (1,5,3)(2,6,4)(7,9,11)(8,10,12),
|
||||
(1,6)(2,5)(3,4)(7,12)(8,11)(9,10), (1,7)(2,8)(3,9)(4,10)(5,11)(6,12),
|
||||
(1,8)(2,7)(3,10)(4,9)(5,12)(6,11), (1,9)(2,12)(3,11)(4,8)(5,7)(6,10),
|
||||
(1,10)(2,11)(3,12)(4,7)(5,8)(6,9), (1,11)(2,10)(3,7)(4,12)(5,9)(6,8),
|
||||
(1,12)(2,9)(3,8)(4,11)(5,10)(6,7) ]
|
||||
gap> LeftTranslation( L, eL[ 3 ] );
|
||||
(1,3,5)(2,6,4)(7,9,11)(8,10,12)
|
||||
gap> RightTranslation( L, eL[ 3 ] );
|
||||
(1,3,5)(2,4,6)(7,11,9)(8,12,10)
|
||||
|
||||
# TESTING MULTIPLICATION GROUPS AND INNER MAPPING GROUPS
|
||||
|
||||
gap> LeftMultiplicationGroup( L );
|
||||
<permutation group with 12 generators>
|
||||
gap> RightMultiplicationGroup( L );
|
||||
<permutation group with 12 generators>
|
||||
gap> Size( MultiplicationGroup( L ) );
|
||||
2592
|
||||
gap> Size( InnerMappingGroup( L ) );
|
||||
216
|
||||
gap> MiddleInnerMappingGroup( L );
|
||||
<permutation group with 12 generators>
|
||||
|
||||
# TESTING LOOP BY LEFT/RIGHT SECTION
|
||||
gap> LoopByRightSection( [ (), (1,2)(3,4,5), (1,3,5)(2,4), (1,4,3)(2,5), (1,5,4)(2,3) ] );
|
||||
<loop of order 5>
|
||||
gap> S := Subloop( MoufangLoop( 12, 1 ), [ 3 ] );;
|
||||
gap> LoopByLeftSection( LeftSection( S ) );
|
||||
<loop of order 3>
|
||||
gap> LoopByRightSection( RightSection( S ) );
|
||||
<loop of order 3>
|
||||
gap> QuasigroupByLeftSection( LeftSection( S ) );
|
||||
<quasigroup of order 3>
|
||||
gap> QuasigroupByRightSection( RightSection( S ) );
|
||||
<quasigroup of order 3>
|
||||
gap> CayleyTableByPerms( LeftSection( S ) );
|
||||
[ [ 1, 3, 5 ], [ 3, 5, 1 ], [ 5, 1, 3 ] ]
|
||||
|
||||
# TESTING LOOP BY RIGHT FOLDER
|
||||
|
||||
gap> LOOPS_Shift := function( p )
|
||||
> local ls;
|
||||
> ls := ListPerm( p );
|
||||
> ls := Concatenation( [1,2,3,4,5], List( ls, x -> x + 5 ) );
|
||||
> return PermList( ls );
|
||||
> end;
|
||||
function( p ) ... end
|
||||
gap> A := AlternatingGroup( 5 );
|
||||
Alt( [ 1 .. 5 ] )
|
||||
gap> G := DirectProduct( A, A );
|
||||
Group([ (1,2,3,4,5), (3,4,5), (6,7,8,9,10), (8,9,10) ])
|
||||
gap> H := Subgroup( G, [ (1,2,3), (2,3,4), (6,7,8,9,10) ] );
|
||||
Group([ (1,2,3), (2,3,4), (6,7,8,9,10) ])
|
||||
gap> T := List( A, x -> x * LOOPS_Shift(x)^(-1) );;
|
||||
gap> LoopByRightFolder( G, H, T );
|
||||
<loop of order 60>
|
||||
gap> QuasigroupByRightFolder( G, H, T );
|
||||
<quasigroup of order 60>
|
||||
|
||||
# TESTING RANDOM QUASIGROUPS AND LOOPS
|
||||
|
||||
gap> RandomQuasigroup( 10 );
|
||||
<quasigroup of order 10>
|
||||
gap> RandomQuasigroup( 10, 100 );
|
||||
<quasigroup of order 10>
|
||||
gap> RandomLoop( 11 );
|
||||
<loop of order 11>
|
||||
gap> RandomLoop( 30, 1000 );
|
||||
<loop of order 30>
|
||||
gap> RandomNilpotentLoop( [2, 3, 5] );
|
||||
<loop of order 30>
|
||||
gap> RandomNilpotentLoop( [2, CyclicGroup(3), 6] );
|
||||
<loop of order 36>
|
||||
|
||||
# TESTING SUBQUASIGROUPS AND SUBLOOPS
|
||||
|
||||
gap> L := MoufangLoop( 32, 5 );;
|
||||
gap> Length( AllSubloops( L ) );
|
||||
90
|
||||
gap> S := Subloop( L, [ Elements( L )[ 2 ], Elements( L )[ 25 ] ] );
|
||||
<loop of order 8>
|
||||
gap> L = Parent( S );
|
||||
true
|
||||
gap> L = Parent( L );
|
||||
true
|
||||
gap> PosInParent( S );
|
||||
[ 1, 2, 5, 8, 22, 25, 29, 31 ]
|
||||
gap> IsSubloop( L, S );
|
||||
true
|
||||
gap> CayleyTable( S );
|
||||
[ [ 1, 2, 5, 8, 22, 25, 29, 31 ], [ 2, 5, 8, 1, 31, 22, 25, 29 ],
|
||||
[ 5, 8, 1, 2, 29, 31, 22, 25 ], [ 8, 1, 2, 5, 25, 29, 31, 22 ],
|
||||
[ 22, 25, 29, 31, 1, 2, 5, 8 ], [ 25, 29, 31, 22, 8, 1, 2, 5 ],
|
||||
[ 29, 31, 22, 25, 5, 8, 1, 2 ], [ 31, 22, 25, 29, 2, 5, 8, 1 ] ]
|
||||
gap> LeftTranslation( S, Elements( S )[ 2 ] );
|
||||
(1,2,5,8)(22,31,29,25)
|
||||
gap> SS := Subloop( S, [ Elements( S )[ 2 ] ] );
|
||||
<loop of order 4>
|
||||
gap> Parent( SS ) = L;
|
||||
true
|
||||
gap> CayleyTable( SS );
|
||||
[ [ 1, 2, 5, 8 ], [ 2, 5, 8, 1 ], [ 5, 8, 1, 2 ], [ 8, 1, 2, 5 ] ]
|
||||
gap> IsSubloop( S, SS );
|
||||
true
|
||||
gap> AllSubquasigroups( QuasigroupByCayleyTable( [[2,1],[1,2]] ) );
|
||||
[ <quasigroup of order 2>, <quasigroup of order 1> ]
|
||||
|
||||
# TESTING NUCLEUS, COMMUTANT, CENTER
|
||||
|
||||
gap> LeftNucleus( L ) = NucleusOfLoop( L );
|
||||
true
|
||||
gap> MiddleNucleus( L ) = RightNucleus( L );
|
||||
true
|
||||
gap> Commutant( L );
|
||||
[ l1, l4, l5, l11 ]
|
||||
gap> Center( L );
|
||||
<associative loop of order 4>
|
||||
gap> AssociatorSubloop( L );
|
||||
<loop of order 2>
|
||||
|
||||
# TESTING COMMUTATIVITY AND GENERALIZATIONS
|
||||
|
||||
gap> IsAssociative( L );
|
||||
false
|
||||
gap> IsCommutative( L );
|
||||
false
|
||||
gap> IsCommutative( Q );
|
||||
true
|
||||
gap> IsPowerAssociative( L );
|
||||
true
|
||||
gap> IsDiassociative( L );
|
||||
true
|
||||
|
||||
# TESTING INVERSE PROPERTIES
|
||||
|
||||
gap> B := LeftBolLoop( 8, 1 );;
|
||||
gap> HasLeftInverseProperty( B );
|
||||
true
|
||||
gap> HasRightInverseProperty( B );
|
||||
false
|
||||
gap> HasInverseProperty( B );
|
||||
false
|
||||
gap> HasTwosidedInverses( B );
|
||||
true
|
||||
gap> HasAutomorphicInverseProperty( B );
|
||||
true
|
||||
gap> HasAntiautomorphicInverseProperty( B );
|
||||
false
|
||||
|
||||
# TESTING PROPERTIES OF QUASIGROUPS
|
||||
|
||||
gap> IsSemisymmetric( Q );
|
||||
true
|
||||
gap> IsTotallySymmetric( Q );
|
||||
true
|
||||
gap> IsTotallySymmetric( B );
|
||||
false
|
||||
gap> IsIdempotent( Q );
|
||||
false
|
||||
gap> IsSteinerQuasigroup( Q );
|
||||
false
|
||||
gap> IsUnipotent( Q );
|
||||
true
|
||||
gap> IsLeftDistributive( B );
|
||||
false
|
||||
gap> IsRightDistributive( B );
|
||||
false
|
||||
gap> IsDistributive( B );
|
||||
false
|
||||
gap> IsEntropic( Q );
|
||||
true
|
||||
gap> IsMedial( Q );
|
||||
true
|
||||
|
||||
# TESTING LOOPS OF BOL-MOUFANG TYPE
|
||||
|
||||
gap> L := DirectProduct( MoufangLoop( 12, 1 ), Group( (1,2)(3,4), (1,3)(2,4) ) );
|
||||
<loop of order 48>
|
||||
gap> IsLeftAlternative( L );
|
||||
true
|
||||
gap> IsRightAlternative( L );
|
||||
true
|
||||
gap> L;
|
||||
<alternative loop of order 48>
|
||||
gap> IsLeftNuclearSquareLoop( L );
|
||||
false
|
||||
gap> IsRightNuclearSquareLoop( L );
|
||||
false
|
||||
gap> IsMiddleNuclearSquareLoop( L );
|
||||
false
|
||||
gap> IsNuclearSquareLoop( L );
|
||||
false
|
||||
gap> IsLCLoop( L );
|
||||
false
|
||||
gap> IsRCLoop( L );
|
||||
false
|
||||
gap> IsCLoop( L );
|
||||
false
|
||||
gap> IsFlexible( L );
|
||||
true
|
||||
gap> IsLeftBolLoop( L );
|
||||
true
|
||||
gap> L;
|
||||
<left Bol loop of order 48>
|
||||
gap> IsRightBolLoop( L );
|
||||
true
|
||||
gap> L;
|
||||
<Moufang loop of order 48>
|
||||
gap> IsExtraLoop( L );
|
||||
false
|
||||
|
||||
# TESTING CONJUGACY CLOSED LOOPS
|
||||
|
||||
gap> IsLCCLoop( L ); IsLeftConjugacyClosedLoop( L );
|
||||
false
|
||||
false
|
||||
gap> IsRCCLoop( L ); IsRightConjugacyClosedLoop( L );
|
||||
false
|
||||
false
|
||||
gap> IsCCLoop( L ); IsConjugacyClosedLoop( L );
|
||||
false
|
||||
false
|
||||
|
||||
# TESTING BRUCK AND STEINER LOOPS
|
||||
|
||||
gap> IsLeftBruckLoop( B );
|
||||
true
|
||||
gap> IsRightBruckLoop( B );
|
||||
false
|
||||
gap> IsLeftKLoop( B );
|
||||
true
|
||||
gap> IsRightKLoop( B );
|
||||
false
|
||||
gap> IsSteinerLoop( B );
|
||||
false
|
||||
|
||||
# TESTING A-LOOPS
|
||||
|
||||
gap> IsLeftALoop( B );
|
||||
true
|
||||
gap> IsRightALoop( B );
|
||||
true
|
||||
gap> IsMiddleALoop( B );
|
||||
false
|
||||
gap> IsALoop( B );
|
||||
false
|
||||
|
||||
# TESTING NORMALITY
|
||||
|
||||
gap> L := MoufangLoop( 32, 27 );;
|
||||
gap> S := Subloop( L, [ L.3, L.4 ] );;
|
||||
gap> IsNormal( L, S );
|
||||
true
|
||||
gap> FactorLoop( L, S );
|
||||
<loop of order 4>
|
||||
gap> NaturalHomomorphismByNormalSubloop( L, S );
|
||||
MappingByFunction( <Moufang loop 32/27>, <loop of order
|
||||
4>, function( x ) ... end )
|
||||
gap> S := Subloop( L, [ Elements( L )[ 7 ] ] );;
|
||||
gap> IsNormal( L, S );
|
||||
false
|
||||
gap> NormalClosure( L, S );
|
||||
<loop of order 8>
|
||||
|
||||
# TESTING NILPOTENCY (MORE TESTING IN FILE nilpot.tst)
|
||||
|
||||
gap> IsNilpotent( L );
|
||||
true
|
||||
gap> IsStronglyNilpotent( L );
|
||||
true
|
||||
gap> UpperCentralSeries( L );
|
||||
[ <loop of order 32>, <loop of order 4>, <loop of order 2>,
|
||||
<associative loop of order 1> ]
|
||||
gap> LowerCentralSeries( L );
|
||||
[ <Moufang loop 32/27>, <loop of order 4>, <loop of order 2>,
|
||||
<associative loop of order 1> ]
|
||||
gap> NilpotencyClassOfLoop( L );
|
||||
3
|
||||
|
||||
# TESTING SOLVABILITY
|
||||
|
||||
gap> IsSolvable( L );
|
||||
true
|
||||
gap> DerivedSubloop( L );
|
||||
<loop of order 4>
|
||||
gap> DerivedLength( L );
|
||||
2
|
||||
gap> FrattiniSubloop( L );
|
||||
<loop of order 4>
|
||||
gap> FrattinifactorSize( L );
|
||||
8
|
||||
|
||||
gap> STOP_TEST( "core_methods.tst", 10000000 );
|
||||
52
tst/iso.tst
Normal file
52
tst/iso.tst
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
#############################################################################
|
||||
##
|
||||
#W iso.tst Testing isomorphisms G. P. Nagy / P. Vojtechovsky
|
||||
##
|
||||
#H @(#)$Id: iso.tst, v 3.2.0 2016/06/02 gap Exp $
|
||||
##
|
||||
#Y Copyright (C) 2004, G. P. Nagy (University of Szeged, Hungary),
|
||||
#Y P. Vojtechovsky (University of Denver, USA)
|
||||
##
|
||||
|
||||
gap> START_TEST("LOOPS, iso: testing isomorphisms");
|
||||
|
||||
# TESTING DISCIMINATOR
|
||||
gap> Length( Discriminator( MoufangLoop( 12, 1 ) )[ 1 ] );
|
||||
3
|
||||
|
||||
# TESTING AUTOMORPHISM GROUPS
|
||||
|
||||
gap> AutomorphismGroup( MoufangLoop( 12, 1 ) );
|
||||
<permutation group with 14 generators>
|
||||
gap> AutomorphismGroup( MoufangLoop( 64, 1235 ) );
|
||||
<permutation group with 16 generators>
|
||||
gap> Size( last );
|
||||
512
|
||||
gap> AutomorphismGroup( LeftBolLoop( 8, 1 ) );
|
||||
Group([ (5,8)(6,7), (2,3)(6,7), (2,6)(3,7), (2,7)(3,6) ])
|
||||
gap> Size( AutomorphismGroup( SteinerLoop( 16, 77 ) ) );
|
||||
3
|
||||
gap> Q := QuasigroupByCayleyTable([[3,2,1],[2,1,3],[1,3,2]]);;
|
||||
gap> AutomorphismGroup( Q );
|
||||
Group([ (1,2,3), (1,3,2) ])
|
||||
|
||||
# TESTING ISOMORPHISMS
|
||||
|
||||
gap> Q := DirectProduct( MoufangLoop( 32, 5 ) );;
|
||||
gap> Qp := IsomorphicCopyByPerm( Q, (2,3,4)(17,20) );;
|
||||
gap> IsomorphismLoops( Q, Qp );
|
||||
(2,3,4)(18,23)(19,25)(21,27)(22,28)(24,30)(26,31)(29,32)
|
||||
gap> LoopsUpToIsomorphism( [Q,Qp] );
|
||||
[ <Moufang loop 32/5> ]
|
||||
gap> Q2 := QuasigroupByCayleyTable( [[2,1],[1,2]] );;
|
||||
gap> IsomorphismQuasigroups( Q2, IntoLoop(CyclicGroup(2)) );
|
||||
(1,2)
|
||||
gap> Length( QuasigroupsUpToIsomorphism( [Q,Q2] ) );
|
||||
2
|
||||
|
||||
# TESTING ISOTOPISMS
|
||||
|
||||
gap> IsotopismLoops( SmallLoop( 5, 1 ), SmallLoop( 5, 4 ) );
|
||||
[ (3,4,5), (1,2), (1,2) ]
|
||||
|
||||
gap> STOP_TEST( "iso.tst", 10000000 );
|
||||
264
tst/lib.tst
Normal file
264
tst/lib.tst
Normal file
|
|
@ -0,0 +1,264 @@
|
|||
#############################################################################
|
||||
##
|
||||
#W lib.tst Testing libraries of loops G. P. Nagy / P. Vojtechovsky
|
||||
##
|
||||
#H @(#)$Id: lib.tst, v 3.3.0 2016/10/26 gap Exp $
|
||||
##
|
||||
#Y Copyright (C) 2004, G. P. Nagy (University of Szeged, Hungary),
|
||||
#Y P. Vojtechovsky (University of Denver, USA)
|
||||
##
|
||||
|
||||
gap> START_TEST("LOOPS, lib: testing all libraries except Moufang");
|
||||
|
||||
# INTERESTING LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo( "interesting" );
|
||||
The library contains a few interesting loops.
|
||||
------
|
||||
Extent of the library:
|
||||
1 loop of order 5
|
||||
1 loop of order 6
|
||||
1 loop of order 16
|
||||
1 loop of order 32
|
||||
1 loop of order 96
|
||||
true
|
||||
|
||||
# number of orders implemented in the library
|
||||
gap> t := Length( LOOPS_interesting_data[ 1 ] );
|
||||
5
|
||||
|
||||
# testing loops
|
||||
gap> for i in [1..t] do
|
||||
> n := LOOPS_interesting_data[ 1 ][ i ];
|
||||
> for m in [ 1..LOOPS_interesting_data[ 2 ][ i ] ] do
|
||||
> InterestingLoop( n, m );
|
||||
> od;
|
||||
> od;
|
||||
|
||||
# LEFT/RIGHT BOL LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo( "left Bol" );
|
||||
The library contains all nonassociative left Bol loops of order less than 17
|
||||
and all nonassociative left Bol loops of order p*q, where p>q>2 are primes.
|
||||
------
|
||||
Extent of the library:
|
||||
6 loops of order 8
|
||||
3 loops of order 12
|
||||
2038 loops of order 16
|
||||
(p-q)/2 loops of order p*q for primes p>q>2 such that q divides p-1
|
||||
(p-q+2)/2 loops of order p*q for primes p>q>2 such that q divides p+1
|
||||
true
|
||||
|
||||
# number of orders implemented in the library
|
||||
gap> t := Length( LOOPS_left_bol_data[ 1 ] );
|
||||
3
|
||||
|
||||
# testing loops
|
||||
gap> for i in [1..t] do
|
||||
> n := LOOPS_left_bol_data[ 1 ][ i ];
|
||||
> for m in [ 1..LOOPS_left_bol_data[ 2 ][ i ] ] do
|
||||
> LeftBolLoop( n, m );
|
||||
> od;
|
||||
> od;
|
||||
|
||||
# testing right Bol loop
|
||||
gap> RightBolLoop( 8, 1 );
|
||||
<right Bol loop 8/1>
|
||||
|
||||
# STEINER LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo( "Steiner" );
|
||||
The library contains all nonassociative Steiner loops
|
||||
of order less or equal to 16. It also contains the
|
||||
associative Steiner loops of order 4 and 8.
|
||||
------
|
||||
Extent of the library:
|
||||
1 loop of order 4
|
||||
1 loop of order 8
|
||||
1 loop of order 10
|
||||
2 loops of order 14
|
||||
80 loops of order 16
|
||||
true
|
||||
|
||||
# number of orders implemented in the library
|
||||
gap> t := Length( LOOPS_steiner_data[ 1 ] );
|
||||
5
|
||||
|
||||
# testing loops
|
||||
gap> for i in [1..t] do
|
||||
> n := LOOPS_steiner_data[ 1 ][ i ];
|
||||
> for m in [ 1..LOOPS_steiner_data[ 2 ][ i ] ] do
|
||||
> SteinerLoop( n, m );
|
||||
> od;
|
||||
> od;
|
||||
|
||||
# NILPOTENT LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo( "nilpotent" );
|
||||
The library contains all nonassociative nilpotent loops
|
||||
of order less than 12.
|
||||
------
|
||||
Extent of the library:
|
||||
2 loops of order 6
|
||||
134 loops of order 8
|
||||
8 loops of order 9
|
||||
1043 loops of order 10
|
||||
true
|
||||
|
||||
gap> NilpotentLoop( 10, 1000 );
|
||||
<nilpotent loop 10/1000>
|
||||
|
||||
# PAIGE LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo( "Paige" );
|
||||
The library contains the smallest nonassociative finite
|
||||
simple Moufang loop.
|
||||
------
|
||||
Extent of the library:
|
||||
1 loop of order 120
|
||||
true
|
||||
|
||||
gap> PaigeLoop( 2 );
|
||||
<Paige loop 120/1>
|
||||
|
||||
# RCC LOOPS
|
||||
gap> DisplayLibraryInfo("RCC");
|
||||
The library contains all nonassociative RCC loops of order less than 28.
|
||||
------
|
||||
Extent of the library:
|
||||
3 loops of order 6
|
||||
19 loops of order 8
|
||||
5 loops of order 9
|
||||
16 loops of order 10
|
||||
155 loops of order 12
|
||||
97 loops of order 14
|
||||
17 loops of order 15
|
||||
6317 loops of order 16
|
||||
1901 loops of order 18
|
||||
8248 loops of order 20
|
||||
119 loops of order 21
|
||||
10487 loops of order 22
|
||||
471995 loops of order 24
|
||||
119 loops of order 25
|
||||
151971 loops of order 26
|
||||
152701 loops of order 27
|
||||
true
|
||||
|
||||
gap> RCCLoop(6,1); RCCLoop(16,6317); RightConjugacyClosedLoop(27,152701);
|
||||
<RCC loop 6/1>
|
||||
<RCC loop 16/6317>
|
||||
<RCC loop 27/152701>
|
||||
|
||||
gap> LCCLoop(6,3); LCCLoop(25,119);
|
||||
<LCC loop 6/3>
|
||||
<LCC loop 25/119>
|
||||
|
||||
# CC LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo("CC");
|
||||
The library contains all nonassociative CC loops of order less than 28
|
||||
and all nonassociative CC loops of order p^2 and 2*p for any odd prime p.
|
||||
------
|
||||
Extent of the library:
|
||||
2 loops of order 8
|
||||
3 loops of order 12
|
||||
28 loops of order 16
|
||||
7 loops of order 18
|
||||
3 loops of order 20
|
||||
1 loop of order 21
|
||||
14 loops of order 24
|
||||
55 loops of order 27
|
||||
3 loops of order p^2 for every odd prime p,
|
||||
1 loop of order 2*p for every odd prime p
|
||||
true
|
||||
|
||||
gap> CCLoop(25,1); CCLoop(49,2); CCLoop(121,3); CCLoop(14,1);
|
||||
<CC loop 25/1>
|
||||
<CC loop 49/2>
|
||||
<CC loop 121/3>
|
||||
<CC loop 14/1>
|
||||
|
||||
gap> CCLoop(16,28); ConjugacyClosedLoop(27,55);
|
||||
<CC loop 16/28>
|
||||
<CC loop 27/55>
|
||||
|
||||
# SMALL LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo("small");
|
||||
The library contains all nonassociative loops of order less than 7.
|
||||
------
|
||||
Extent of the library:
|
||||
5 loops of order 5
|
||||
107 loops of order 6
|
||||
true
|
||||
|
||||
gap> SmallLoop( 5, 3 ); SmallLoop( 6, 12 );
|
||||
<small loop 5/3>
|
||||
<small loop 6/12>
|
||||
|
||||
# ITP SMALL LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo("itp small");
|
||||
The library contains all nonassociative loops of order less than 7 up to isoto\
|
||||
pism.
|
||||
------
|
||||
Extent of the library:
|
||||
1 loop of order 5
|
||||
20 loops of order 6
|
||||
true
|
||||
|
||||
gap> ItpSmallLoop( 5, 1 ); ItpSmallLoop( 6, 14 );
|
||||
<small loop 5/1>
|
||||
<small loop 6/42>
|
||||
|
||||
# CODE LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo("code");
|
||||
The library contains all nonassociative even code loops
|
||||
of order less than 65.
|
||||
------
|
||||
Extent of the library:
|
||||
5 loops of order 16
|
||||
16 loops of order 32
|
||||
80 loops of order 64
|
||||
true
|
||||
|
||||
gap> CodeLoop( 16, 3 );
|
||||
<Moufang loop 16/3>
|
||||
gap> CodeLoop( 64, 80 );
|
||||
<Moufang loop 64/4247>
|
||||
|
||||
# AUTOMORPHIC LOOPS
|
||||
|
||||
gap> DisplayLibraryInfo("automorphic");
|
||||
The library contains:
|
||||
- all nonassociative automorphic loops of order less than 16,
|
||||
- all commutative automorphic loops of order 3, 9, 27, 81,
|
||||
- all commutative automorphic loops of order 243 that are central
|
||||
extensions of Z_3 by F, where F is not the elem. ab. 3-group.
|
||||
Note: Abelian groups are included among the commutative loops.
|
||||
------
|
||||
Extent of the library:
|
||||
1 loop of order 3
|
||||
1 loop of order 6
|
||||
7 loops of order 8
|
||||
2 loops of order 9
|
||||
3 loops of order 10
|
||||
2 loops of order 12
|
||||
5 loops of order 14
|
||||
2 loops of order 15
|
||||
7 loops of order 27
|
||||
72 loops of order 81
|
||||
118451 loops of order 243
|
||||
true
|
||||
|
||||
gap> AutomorphicLoop(15,2);
|
||||
<automorphic loop 15/2>
|
||||
|
||||
gap> AutomorphicLoop(27,1);
|
||||
<automorphic loop 27/1>
|
||||
|
||||
gap> AutomorphicLoop(243,100);
|
||||
<automorphic loop 243/100>
|
||||
|
||||
gap> STOP_TEST( "lib.tst", 10000000 );
|
||||
66
tst/nilpot.tst
Normal file
66
tst/nilpot.tst
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
#############################################################################
|
||||
##
|
||||
#W nilpot.tst Testing nilpotency G. P. Nagy / P. Vojtechovsky
|
||||
##
|
||||
#H @(#)$Id: nilpot.tst, v 3.2.0 2015/11/22 gap Exp $
|
||||
##
|
||||
#Y Copyright (C) 2004, G. P. Nagy (University of Szeged, Hungary),
|
||||
#Y P. Vojtechovsky (University of Denver, USA)
|
||||
##
|
||||
|
||||
gap> START_TEST("LOOPS, nilpot: nilpotency and triality group");
|
||||
|
||||
# GENERAL NILPOTENCY
|
||||
|
||||
gap> L := LoopByCayleyTable(
|
||||
> [ [ 1, 2, 3, 4, 5, 6, 7, 8 ], [ 2, 1, 4, 3, 6, 5, 8, 7 ],
|
||||
> [ 3, 4, 1, 2, 7, 8, 5, 6 ], [ 4, 6, 2, 8, 1, 7, 3, 5 ],
|
||||
> [ 5, 3, 7, 1, 8, 2, 6, 4 ], [ 6, 5, 8, 7, 2, 1, 4, 3 ],
|
||||
> [ 7, 8, 5, 6, 3, 4, 1, 2 ], [ 8, 7, 6, 5, 4, 3, 2, 1 ] ] );
|
||||
<loop of order 8>
|
||||
gap> Center(L);
|
||||
<associative loop of order 2>
|
||||
gap> LeftNucleus(L);
|
||||
<associative loop of order 2>
|
||||
gap> RightNucleus(L);
|
||||
<associative loop of order 4>
|
||||
gap> IsNilpotent(L);
|
||||
true
|
||||
gap> NilpotencyClassOfLoop(L);
|
||||
2
|
||||
gap> IsomorphismLoops(L,LeftBolLoop(8,2));
|
||||
(3,8,4,6,5,7)
|
||||
|
||||
# NILPOTENCY FOR MOUFANG LOOPS
|
||||
|
||||
gap> L:=MoufangLoop(24,1);
|
||||
<Moufang loop 24/1>
|
||||
gap> Center(L);
|
||||
<associative loop of order 2>
|
||||
gap> IsNilpotent(L);
|
||||
false
|
||||
gap> NilpotencyClassOfLoop(L);
|
||||
fail
|
||||
gap> L:=MoufangLoop(32,32);
|
||||
<Moufang loop 32/32>
|
||||
gap> Center(L);
|
||||
<associative loop of order 2>
|
||||
|
||||
# TRIALITY GROUPS
|
||||
|
||||
gap> tr:=TrialityPermGroup(L);;
|
||||
gap> [ 33^tr.rho, 33^tr.sigma ];
|
||||
[ 65, 1 ]
|
||||
gap> Size(Center(tr.group));
|
||||
4
|
||||
gap> tr_pc:=TrialityPcGroup(L);
|
||||
rec( group := <Triality pc group of order 2^15>, rho := f2, sigma := f1 )
|
||||
gap> Size(Centralizer(tr.group,tr.sigma));
|
||||
1024
|
||||
gap> Size(Centralizer(tr.group,tr.rho));
|
||||
32
|
||||
gap> TrialityPermGroup(PSL(2,5));;
|
||||
gap> Size(last.group);
|
||||
216000
|
||||
|
||||
gap> STOP_TEST( "nilpot.tst", 10000000 );
|
||||
16
tst/testall.g
Normal file
16
tst/testall.g
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
#############################################################################
|
||||
##
|
||||
#W testall.g Testing LOOPS G. P. Nagy / P. Vojtechovsky
|
||||
##
|
||||
#H @(#)$Id: testall.g, v 3.0.0 2015/06/15 gap Exp $
|
||||
##
|
||||
#Y Copyright (C) 2004, G. P. Nagy (University of Szeged, Hungary),
|
||||
#Y P. Vojtechovsky (University of Denver, USA)
|
||||
##
|
||||
|
||||
dirs := DirectoriesPackageLibrary( "loops", "tst" );
|
||||
ReadTest( Filename( dirs, "core_methods.tst" ) );
|
||||
ReadTest( Filename( dirs, "nilpot.tst" ) );
|
||||
ReadTest( Filename( dirs, "iso.tst" ) );
|
||||
ReadTest( Filename( dirs, "lib.tst" ) );
|
||||
ReadTest( Filename( dirs, "bol.tst" ) );
|
||||
Loading…
Add table
Add a link
Reference in a new issue