|
#############################################################################
##
#W classes.gi Testing properties/varieties [loops]
##
##
#Y Copyright (C) 2004, G. P. Nagy (University of Szeged, Hungary),
#Y P. Vojtechovsky (University of Denver, USA)
##
#############################################################################
## ASSOCIATIVITY, COMMUTATIVITY AND GENERALIZATIONS
## -------------------------------------------------------------------------
# (PROG) IsAssociative is already implemented for magmas, but we provide
# a new method based on sections. This new method is much faster for groups,
# and a bit slower for nonassociative loops.
InstallOtherMethod( IsAssociative, "for loops",
[ IsLoop ], 0,
function( Q )
local sLS, x, y;
sLS := Set( LeftSection( Q ) );
for x in LeftSection( Q ) do
for y in LeftSection( Q ) do
if not x*y in sLS then return false; fi;
od;
od;
return true;
end);
# implies
# InstallTrueMethod( IsExtraLoop, IsAssociative and IsLoop );
#############################################################################
##
#P IsCommutative( Q )
##
## Returns true if <Q> is commutative.
InstallOtherMethod( IsCommutative, "for quasigroup",
[ IsQuasigroup ],
function( Q )
return LeftSection( Q ) = RightSection( Q );
end );
#############################################################################
##
#P IsPowerAssociative( Q )
##
## Returns true if <Q> is a power associative quasigroup.
InstallOtherMethod( IsPowerAssociative, "for quasigroup",
[ IsQuasigroup ],
function( Q )
local checked, x, S;
checked := [];
repeat
x := Difference( Elements(Q), checked );
if IsEmpty( x ) then
return true;
fi;
S := Subquasigroup( Q, [x[1]] );
if not IsAssociative( S ) then
return false;
fi;
checked := Union( checked, Elements( S ) ); # S is a group, so every subquasigroup of S is a group
until 0=1;
end );
# implies
# InstallTrueMethod( HasTwosidedInverses, IsPowerAssociative and IsLoop );
#############################################################################
##
#P IsDiassociative( Q )
##
## Returns true if <Q> is a diassociative quasigroup.
InstallOtherMethod( IsDiassociative, "for quasigroup",
[ IsQuasigroup ],
function( Q )
local checked, all_pairs, x, S;
checked := [];
all_pairs := Combinations( PosInParent( Elements( Q ) ), 2 ); # it is faster to work with integers
repeat
x := Difference( all_pairs, checked );
if IsEmpty( x ) then
return true;
fi;
S := Subquasigroup( Q, x[1] );
if not IsAssociative( S ) then
return false;
fi;
checked := Union( checked, Combinations( PosInParent( Elements( S ) ), 2 ) );
until 0=1;
end );
# implies
# InstallTrueMethod( IsPowerAlternative, IsDiassociative );
# InstallTrueMethod( IsFlexible, IsDiassociative );
#############################################################################
## INVERSE PROPERTIES
## -------------------------------------------------------------------------
#############################################################################
##
#P HasLeftInverseProperty( L )
##
## Returns true if <L> has the left inverse property.
InstallMethod( HasLeftInverseProperty, "for loop",
[ IsLoop ],
function( L )
return ForAll( LeftSection( L ), a -> a^-1 in LeftSection( L ) );
end );
#############################################################################
##
#P HasRightInverseProperty( L )
##
## Returns true if <L> has the right inverse property.
InstallMethod( HasRightInverseProperty, "for loop",
[ IsLoop ],
function( L )
return ForAll( RightSection( L ), a -> a^-1 in RightSection( L ) );
end );
#############################################################################
##
#P HasInverseProperty( L )
##
## Returns true if <L> has the inverse property.
InstallMethod( HasInverseProperty, "for loop",
[ IsLoop ],
function( L )
return HasLeftInverseProperty( L ) and HasRightInverseProperty( L );
end );
#############################################################################
##
#P HasWeakInverseProperty( L )
##
## Returns true if <L> has the weak inverse property.
InstallMethod( HasWeakInverseProperty, "for loop",
[ IsLoop ],
function( L )
return ForAll( L, x -> ForAll( L, y -> LeftInverse(x*y)*x=LeftInverse(y) ));
end );
#############################################################################
##
#P HasTwosidedInverses( L )
##
## Returns true if <L> has two-sided inverses.
InstallMethod( HasTwosidedInverses, "for loop",
[ IsLoop ],
function( L )
return ForAll( L, x -> LeftInverse( x ) = RightInverse( x ) );
end );
#############################################################################
##
#P HasAutomorphicInverseProperty( L )
##
## Returns true if <L> has the automorphic inverse property.
InstallMethod( HasAutomorphicInverseProperty, "for loop",
[ IsLoop ],
function( L )
return ForAll( L, x -> ForAll( L, y ->
LeftInverse( x*y ) = LeftInverse( x )*LeftInverse( y ) ) );
end );
#############################################################################
##
#P HasAntiautomorphicInverseProperty( L )
##
## Returns true if <L> has the antiautomorphic inverse property.
InstallMethod( HasAntiautomorphicInverseProperty, "for loop",
[ IsLoop ],
function( L )
return ForAll( L, x -> ForAll( L, y ->
LeftInverse( x*y ) = LeftInverse( y )*LeftInverse( x ) ) );
end );
# implies and is implied by (for inverse properties)
# InstallTrueMethod( HasAntiautomorphicInverseProperty, HasAutomorphicInverseProperty and IsCommutative );
# InstallTrueMethod( HasAutomorphicInverseProperty, HasAntiautomorphicInverseProperty and IsCommutative );
# InstallTrueMethod( HasLeftInverseProperty, HasInverseProperty );
# InstallTrueMethod( HasRightInverseProperty, HasInverseProperty );
# InstallTrueMethod( HasWeakInverseProperty, HasInverseProperty );
# InstallTrueMethod( HasAntiautomorphicInverseProperty, HasInverseProperty );
# InstallTrueMethod( HasTwosidedInverses, HasAntiautomorphicInverseProperty );
# InstallTrueMethod( HasInverseProperty, HasLeftInverseProperty and IsCommutative );
# InstallTrueMethod( HasInverseProperty, HasRightInverseProperty and IsCommutative );
# InstallTrueMethod( HasInverseProperty, HasLeftInverseProperty and HasRightInverseProperty );
# InstallTrueMethod( HasInverseProperty, HasLeftInverseProperty and HasWeakInverseProperty );
# InstallTrueMethod( HasInverseProperty, HasRightInverseProperty and HasWeakInverseProperty );
# InstallTrueMethod( HasInverseProperty, HasLeftInverseProperty and HasAntiautomorphicInverseProperty );
# InstallTrueMethod( HasInverseProperty, HasRightInverseProperty and HasAntiautomorphicInverseProperty );
# InstallTrueMethod( HasInverseProperty, HasWeakInverseProperty and HasAntiautomorphicInverseProperty );
# InstallTrueMethod( HasTwosidedInverses, HasLeftInverseProperty );
# InstallTrueMethod( HasTwosidedInverses, HasRightInverseProperty );
# InstallTrueMethod( HasTwosidedInverses, IsFlexible and IsLoop );
#############################################################################
## PROPERTIES OF QUASIGROUPS
## -------------------------------------------------------------------------
#############################################################################
##
#P IsSemisymmetric( Q )
##
## Returns true if the quasigroup <Q> is semisymmetric, i.e., (xy)x=y.
InstallMethod( IsSemisymmetric, "for quasigroup",
[ IsQuasigroup ],
function( Q )
return ForAll( Q, x ->
LeftTranslation( Q, x ) * RightTranslation( Q, x ) = () );
end );
#############################################################################
##
#P IsTotallySymmetric( Q )
##
## Returns true if the quasigroup <Q> is totally symmetric, i.e,
## commutative and semisymmetric.
InstallMethod( IsTotallySymmetric, "for quasigroup",
[ IsQuasigroup ],
function( Q )
return IsCommutative( Q ) and IsSemisymmetric( Q );
end );
#############################################################################
##
#P IsIdempotent( Q )
##
## Returns true if the quasigroup <Q> is idempotent, i.e., x*x=x.
InstallMethod( IsIdempotent, "for quasigroup",
[ IsQuasigroup ],
function( Q )
return ForAll( Q, x -> x*x = x );
end );
#############################################################################
##
#P IsSteinerQuasigroup( Q )
##
## Returns true if the quasigroup <Q> is a Steiner quasigroup, i.e.,
## idempotent and totally symmetric.
InstallMethod( IsSteinerQuasigroup, "for quasigroup",
[ IsQuasigroup ],
function( Q )
return IsIdempotent( Q ) and IsTotallySymmetric( Q );
end );
#############################################################################
##
#P IsUnipotent( Q )
##
## Returns true if the quasigroup <Q> is unipotent, i.e., x*x=y*y.
InstallMethod( IsUnipotent, "for quasigroup",
[ IsQuasigroup ],
function( Q )
local square;
if IsLoop( Q ) then return IsIdempotent( Q ); fi;
square := Elements( Q )[ 1 ]^2;
return ForAll( Q, y -> y^2 = square );
end );
#############################################################################
##
#P IsLDistributive( Q )
##
## Returns true if the quasigroup <Q> is left distributive.
InstallOtherMethod( IsLDistributive, "for Quasigroup",
[ IsQuasigroup ],
function( Q )
# BETTER ALGORITHM LATER?
local x, y, z;
for x in Q do for y in Q do for z in Q do
if not x*(y*z) = (x*y)*(x*z) then return false; fi;
od; od; od;
return true;
end );
#############################################################################
##
#P IsRDistributive( Q )
##
## Returns true if the quasigroup <Q> is right distributive.
InstallOtherMethod( IsRDistributive, "for Quasigroup",
[ IsQuasigroup ],
function( Q )
# BETTER ALGORITHM LATER?
local x, y, z;
for x in Q do for y in Q do for z in Q do
if not (x*y)*z = (x*z)*(y*z) then return false; fi;
od; od; od;
return true;
end );
#############################################################################
##
#P IsEntropic( Q )
##
## Returns true if the quasigroup <Q> is entropic.
InstallMethod( IsEntropic, "for quasigroup",
[ IsQuasigroup ],
function( Q )
# BETTER ALGORITHM LATER?
local x, y, z, w;
for x in Q do for y in Q do for z in Q do for w in Q do
if not (x*y)*(z*w) = (x*z)*(y*w) then return false; fi;
od; od; od; od;
return true;
end );
#############################################################################
## LOOPS OF BOL-MOUFANG
## -------------------------------------------------------------------------
#############################################################################
##
#P IsExtraLoop( L )
##
## Returns true if <L> is an extra loop.
InstallMethod( IsExtraLoop, "for loop",
[ IsLoop ],
function( L )
return IsMoufangLoop( L ) and IsNuclearSquareLoop( L );
end );
# implies
# InstallTrueMethod( IsMoufangLoop, IsExtraLoop );
# InstallTrueMethod( IsCLoop, IsExtraLoop );
# is implied by
# InstallTrueMethod( IsExtraLoop, IsMoufangLoop and IsLeftNuclearSquareLoop );
# InstallTrueMethod( IsExtraLoop, IsMoufangLoop and IsMiddleNuclearSquareLoop );
# InstallTrueMethod( IsExtraLoop, IsMoufangLoop and IsRightNuclearSquareLoop );
#############################################################################
##
#P IsMoufangLoop( L )
##
## Returns true if <L> is a Moufang loop.
InstallMethod( IsMoufangLoop, "for loop",
[ IsLoop ],
function( L )
return IsLeftBolLoop( L ) and HasRightInverseProperty( L );
end );
# implies
# InstallTrueMethod( IsLeftBolLoop, IsMoufangLoop );
# InstallTrueMethod( IsRightBolLoop, IsMoufangLoop );
# InstallTrueMethod( IsDiassociative, IsMoufangLoop );
# is implied by
# InstallTrueMethod( IsMoufangLoop, IsLeftBolLoop and IsRightBolLoop );
#############################################################################
##
#P IsCLoop( L )
##
## Returns true if <L> is a C-loop.
InstallMethod( IsCLoop, "for loop",
[ IsLoop ],
function( L )
return IsLCLoop( L ) and IsRCLoop( L );
end );
# implies
# InstallTrueMethod( IsLCLoop, IsCLoop );
# InstallTrueMethod( IsRCLoop, IsCLoop );
# InstallTrueMethod( IsDiassociative, IsCLoop and IsFlexible);
# is implied by
# InstallTrueMethod( IsCLoop, IsLCLoop and IsRCLoop );
#############################################################################
##
#P IsLeftBolLoop( L )
##
## Returns true if <L> is a left Bol loop.
InstallMethod( IsLeftBolLoop, "for loop",
[ IsLoop ],
function( L )
return ForAll( LeftSection( L ), a ->
ForAll( LeftSection( L ), b -> a*b*a in LeftSection( L ) ) );
end );
# implies
# InstallTrueMethod( IsRightBolLoop, IsLeftBolLoop and IsCommutative );
# InstallTrueMethod( IsLeftPowerAlternative, IsLeftBolLoop );
#############################################################################
##
#P IsRightBolLoop( L )
##
## Returns true if <L> is a right Bol loop.
InstallMethod( IsRightBolLoop, "for loop",
[ IsLoop ],
function( L )
return ForAll( RightSection( L ), a ->
ForAll( RightSection( L ), b -> a*b*a in RightSection( L ) ) );
end );
# implies
# InstallTrueMethod( IsLeftBolLoop, IsRightBolLoop and IsCommutative );
# InstallTrueMethod( IsRightPowerAlternative, IsRightBolLoop );
#############################################################################
##
#P IsLCLoop( L )
##
## Returns true if <L> is an LC-loop.
InstallMethod( IsLCLoop, "for loop",
[ IsLoop ],
function( L )
return ForAll( LeftSection( L ), a ->
ForAll( RightSection( L ), b -> b^(-1)*a*a*b in LeftSection( L ) ) );
end );
# implies
# InstallTrueMethod( IsLeftPowerAlternative, IsLCLoop );
# InstallTrueMethod( IsLeftNuclearSquareLoop, IsLCLoop );
# InstallTrueMethod( IsMiddleNuclearSquareLoop, IsLCLoop );
# InstallTrueMethod( IsRCLoop, IsLCLoop and IsCommutative );
#############################################################################
##
#P IsRCLoop( L )
##
## Returns true if <L> is an RC-loop.
InstallMethod( IsRCLoop, "for loop",
[ IsLoop ],
function( L )
return ForAll( LeftSection( L ), a ->
ForAll( RightSection( L ), b -> a^(-1)*b*b*a in RightSection( L ) ) );
end );
# implies
# InstallTrueMethod( IsRightPowerAlternative, IsRCLoop );
# InstallTrueMethod( IsRightNuclearSquareLoop, IsRCLoop );
# InstallTrueMethod( IsMiddleNuclearSquareLoop, IsRCLoop );
# InstallTrueMethod( IsLCLoop, IsRCLoop and IsCommutative );
#############################################################################
##
#P IsLeftNuclearSquareLoop( L )
##
## Returns true if <L> is a left nuclear square loop.
InstallMethod( IsLeftNuclearSquareLoop, "for loop",
[ IsLoop ],
function( L )
return ForAll( L, x -> x^2 in LeftNucleus( L ) );
end );
#implies
# InstallTrueMethod( IsRightNuclearSquareLoop, IsLeftNuclearSquareLoop and IsCommutative );
#############################################################################
##
#P IsMiddleNuclearSquareLoop( L )
##
## Returns true if <L> is a middle nuclear square loop.
InstallMethod( IsMiddleNuclearSquareLoop, "for loop",
[ IsLoop ],
function( L )
return ForAll( L, x -> x^2 in MiddleNucleus( L ) );
end );
#############################################################################
##
#P IsRightNuclearSquareLoop( L )
##
## Returns true if <L> is a right nuclear square loop.
InstallMethod( IsRightNuclearSquareLoop, "for loop",
[ IsLoop ],
function( L )
return ForAll( L, x -> x^2 in RightNucleus( L ) );
end );
# implies
# InstallTrueMethod( IsLeftNuclearSquareLoop, IsRightNuclearSquareLoop and IsCommutative );
#############################################################################
##
#P IsNuclearSquareLoop( L )
##
## Returns true if <L> is a nuclear square loop.
InstallMethod( IsNuclearSquareLoop, "for loop",
[ IsLoop ],
function( L )
return IsLeftNuclearSquareLoop( L ) and IsRightNuclearSquareLoop( L )
and IsMiddleNuclearSquareLoop( L );
end );
# implies
# InstallTrueMethod( IsLeftNuclearSquareLoop, IsNuclearSquareLoop );
# InstallTrueMethod( IsRightNuclearSquareLoop, IsNuclearSquareLoop );
# InstallTrueMethod( IsMiddleNuclearSquareLoop, IsNuclearSquareLoop );
# is implied by
# InstallTrueMethod( IsNuclearSquareLoop, IsLeftNuclearSquareLoop
# and IsRightNuclearSquareLoop and IsMiddleNuclearSquareLoop );
#############################################################################
##
#P IsFlexible( Q )
##
## Returns true if <Q> is a flexible quasigroup.
InstallMethod( IsFlexible, "for quasigroup",
[ IsQuasigroup ],
function( Q )
local LS, RS;
LS := LeftSection( Q );
RS := RightSection( Q );
return ForAll( [1..Size( Q )], i -> LS[ i ] * RS[ i ] = RS[ i ] * LS[ i ] );
end );
# is implied by
# InstallTrueMethod( IsFlexible, IsCommutative );
#############################################################################
##
#P IsLeftAlternative( Q )
##
## Returns true if <Q> is a left alternative quasigroup.
InstallMethod( IsLeftAlternative, "for quasigroup",
[ IsQuasigroup],
function( Q )
if IsLoop( Q ) then
return ForAll( LeftSection( Q ), a -> a*a in LeftSection( Q ) );
fi;
return ForAll( Q, x -> ForAll( Q, y -> x*(x*y) = (x*x)*y ) );
end );
# implies
# InstallTrueMethod( IsRightAlternative, IsLeftAlternative and IsCommutative );
#############################################################################
##
#P IsRightAlternative( Q )
##
## Returns true if <Q> is a right alternative quasigroup.
InstallMethod( IsRightAlternative, "for quasigroup",
[ IsQuasigroup ],
function( Q )
if IsLoop( Q ) then
return ForAll( RightSection( Q ), a -> a*a in RightSection( Q ) );
fi;
return ForAll( Q, x -> ForAll( Q, y -> (x*y)*y = x*(y*y) ) );
end );
# implies
# InstallTrueMethod( IsLeftAlternative, IsRightAlternative and IsCommutative );
#############################################################################
##
#P IsAlternative( Q )
##
## Returns true if <Q> is an alternative quasigroup.
InstallMethod( IsAlternative, "for quasigroup",
[ IsQuasigroup ],
function( Q )
return IsLeftAlternative( Q ) and IsRightAlternative( Q );
end );
# implies
# InstallTrueMethod( IsLeftAlternative, IsAlternative );
# InstallTrueMethod( IsRightAlternative, IsAlternative );
# is implied by
# InstallTrueMethod( IsAlternative, IsLeftAlternative and IsRightAlternative );
#############################################################################
## POWER ALTERNATIVE LOOPS
## -------------------------------------------------------------------------
#############################################################################
##
#P IsLeftPowerAlternative( L )
##
## Returns true if <L> is a left power alternative loop.
InstallMethod( IsLeftPowerAlternative, "for loop",
[ IsLoop ],
function( L )
local i, M;
if Size( L ) = 1 then return true; fi;
for i in [ 2..Size( L )] do
M := Subloop( L, [ Elements( L )[ i ] ]);
if not Size( RelativeLeftMultiplicationGroup( L, M ) ) = Size( M ) then
return false;
fi;
od;
return true;
end );
# implies
# InstallTrueMethod( IsLeftAlternative, IsLeftPowerAlternative );
# InstallTrueMethod( HasLeftInverseProperty, IsLeftPowerAlternative );
# InstallTrueMethod( IsPowerAssociative, IsLeftPowerAlternative );
#############################################################################
##
#P IsRightPowerAlternative( L )
##
## Returns true if <L> is a right power alternative loop.
InstallMethod( IsRightPowerAlternative, "for loop",
[ IsLoop ],
function( L )
local i, M;
if Size( L ) = 1 then return true; fi;
for i in [ 2..Size( L ) ] do
M := Subloop( L, [ Elements( L )[ i ] ] );
if not Size( RelativeRightMultiplicationGroup( L, M ) ) = Size( M ) then
return false;
fi;
od;
return true;
end );
# implies
# InstallTrueMethod( IsRightAlternative, IsRightPowerAlternative );
# InstallTrueMethod( HasRightInverseProperty, IsRightPowerAlternative );
# InstallTrueMethod( IsPowerAssociative, IsRightPowerAlternative );
#############################################################################
##
#P IsPowerAlternative( L )
##
## Returns true if <L> is a power alternative loop.
InstallMethod( IsPowerAlternative, "for loop",
[ IsLoop ],
function( L )
return ( IsLeftPowerAlternative( L ) and IsRightPowerAlternative( L ) );
end );
# implies
# InstallTrueMethod( IsLeftPowerAlternative, IsPowerAlternative );
# InstallTrueMethod( IsRightPowerAlternative, IsPowerAlternative );
#############################################################################
## CC-LOOPS AND RELATED PROPERTIES
## -------------------------------------------------------------------------
#############################################################################
##
#P IsLCCLoop( L )
##
## Returns true if <L> is a left conjugacy closed loop.
InstallMethod( IsLCCLoop, "for loop",
[ IsLoop ],
function( L )
return ForAll( LeftSection( L ), a ->
ForAll( LeftSection( L ), b -> b*a*b^(-1) in LeftSection( L ) ) );
end );
# implies
# InstallTrueMethod( IsAssociative, IsLCCLoop and IsCommutative );
# InstallTrueMethod( IsExtraLoop, IsLCCLoop and IsMoufangLoop );
#############################################################################
##
#P IsRCCLoop( L )
##
## Returns true if <L> is a right conjugacy closed loop.
InstallMethod( IsRCCLoop, "for loop",
[ IsLoop ],
function( L )
return ForAll( RightSection( L ), a ->
ForAll( RightSection( L ), b -> b*a*b^(-1) in RightSection( L ) ) );
end );
# implies
# InstallTrueMethod( IsAssociative, IsRCCLoop and IsCommutative );
# InstallTrueMethod( IsExtraLoop, IsRCCLoop and IsMoufangLoop );
#############################################################################
##
#P IsCCLoop( L )
##
## Returns true if <L> is a conjugacy closed loop.
InstallMethod( IsCCLoop, "for loop",
[ IsLoop ],
function( L )
return IsLCCLoop( L ) and IsRCCLoop( L );
end );
# implies
# InstallTrueMethod( IsLCCLoop, IsCCLoop );
# InstallTrueMethod( IsRCCLoop, IsCCLoop );
# is implied by
# InstallTrueMethod( IsCCLoop, IsLCCLoop and IsRCCLoop );
#############################################################################
##
#P IsOsbornLoop( L )
##
## Returns true if <L> is an Osborn loop.
InstallMethod( IsOsbornLoop, "for loop",
[ IsLoop ],
function( L )
# MIGHT REDO LATER
return ForAll(L, x-> ForAll(L, y->
ForAll(L, z-> x*((y*z)*x) = LeftDivision(LeftInverse(x),y)*(z*x))
));
end );
# is implied by
# InstallTrueMethod( IsOsbornLoop, IsMoufangLoop );
# InstallTrueMethod( IsOsbornLoop, IsCCLoop );
#############################################################################
## ADDITIONAL VARIETIES OF LOOPS
## -------------------------------------------------------------------------
#############################################################################
##
#P IsCodeLoop( L )
##
## Returns true if <L> is an even code loop.
InstallMethod( IsCodeLoop, "for loop",
[ IsLoop ],
function( L )
# even code loops are precisely Moufang 2-loops with Frattini subloop of order 1, 2
return Set( Factors( Size( L ) ) ) = [ 2 ]
and IsMoufangLoop( L )
and Size( FrattiniSubloop( L ) ) in [1, 2];
end );
# implies
# InstallTrueMethod( IsExtraLoop, IsCodeLoop );
# InstallTrueMethod( IsCCLoop, IsCodeLoop );
#############################################################################
##
#P IsSteinerLoop( L )
##
## Returns true if <L> is a Steiner loop.
InstallMethod( IsSteinerLoop, "for loop",
[ IsLoop ],
function( L )
# Steiner loops are inverse property loops of exponent at most 2.
return HasInverseProperty( L ) and Exponent( L )<=2;
end );
# implies
# InstallTrueMethod( IsCommutative, IsSteinerLoop );
# InstallTrueMethod( IsCLoop, IsSteinerLoop );
#############################################################################
##
#P IsLeftBruckLoop( L )
##
## Returns true if <L> is a left Bruck loop.
InstallMethod( IsLeftBruckLoop, "for loop",
[ IsLoop ],
function( L )
return IsLeftBolLoop( L ) and HasAutomorphicInverseProperty( L );
end );
# implies
# InstallTrueMethod( HasAutomorphicInverseProperty, IsLeftBruckLoop );
# InstallTrueMethod( IsLeftBolLoop, IsLeftBruckLoop );
# InstallTrueMethod( IsRightBruckLoop, IsLeftBruckLoop and IsCommutative );
# is implied by
# InstallTrueMethod( IsLeftBruckLoop, IsLeftBolLoop and HasAutomorphicInverseProperty );
#############################################################################
##
#P IsRightBruckLoop( L )
##
## Returns true if <L> is a right Bruck loop.
InstallMethod( IsRightBruckLoop, "for loop",
[ IsLoop ],
function( L )
return IsRightBolLoop( L ) and HasAutomorphicInverseProperty( L );
end );
# implies
# InstallTrueMethod( HasAutomorphicInverseProperty, IsRightBruckLoop );
# InstallTrueMethod( IsRightBolLoop, IsRightBruckLoop );
# InstallTrueMethod( IsLeftBruckLoop, IsRightBruckLoop and IsCommutative );
# is implied by
# InstallTrueMethod( IsRightBruckLoop, IsRightBolLoop and HasAutomorphicInverseProperty );
#############################################################################
##
#P IsLeftALoop( L )
##
## Returns true if <L> is a left A-loop, that is if
## all left inner mappings are automorphisms of <L>.
InstallMethod( IsLeftALoop, "for loop",
[ IsLoop ],
function( L )
local gens;
gens := GeneratorsOfGroup( LeftInnerMappingGroup( L ) );
return ForAll(gens, f -> ForAll(L, x -> ForAll(L, y -> (x * y)^f = x^f * y^f )));
end);
#############################################################################
##
#P IsRightALoop( L )
##
## Returns true if <L> is a right A-loop, that is if
## all right inner mappings are automorphisms of <L>.
InstallMethod( IsRightALoop, "for loop",
[ IsLoop ],
function( L )
local gens;
gens := GeneratorsOfGroup( RightInnerMappingGroup( L ) );
return ForAll(gens, f -> ForAll(L, x -> ForAll(L, y -> (x * y)^f = x^f * y^f )));
end);
#############################################################################
##
#P IsMiddleALoop( L )
##
## Returns true if <L> is a middle A-loop, that is if
## all middle inner mappings (conjugations) are automorphisms of <L>.
InstallMethod( IsMiddleALoop, "for loop",
[ IsLoop ],
function( L )
local gens;
gens := GeneratorsOfGroup( MiddleInnerMappingGroup( L ) );
return ForAll(gens, f -> ForAll(L, x -> ForAll(L, y -> (x * y)^f = x^f * y^f )));
end);
#############################################################################
##
#P IsALoop( L )
##
## Returns true if <L> is an A-loop, that is if
## all inner mappings are automorphisms of <L>.
InstallMethod( IsALoop, "for loop",
[ IsLoop ],
function( Q )
return IsRightALoop(Q) and IsMiddleALoop(Q);
# Theorem: right A-loop + middle A-loop implies left A-loop
end);
# implies
# InstallTrueMethod( IsLeftALoop, IsALoop );
# InstallTrueMethod( IsRightALoop, IsALoop );
# InstallTrueMethod( IsMiddleALoop, IsALoop );
# InstallTrueMethod( IsLeftALoop, IsRightALoop and HasAntiautomorphicInverseProperty );
# InstallTrueMethod( IsRightALoop, IsLeftALoop and HasAntiautomorphicInverseProperty );
# InstallTrueMethod( IsFlexible, IsMiddleALoop );
# InstallTrueMethod( HasAntiautomorphicInverseProperty, IsFlexible and IsLeftALoop );
# InstallTrueMethod( HasAntiautomorphicInverseProperty, IsFlexible and IsRightALoop );
# InstallTrueMethod( IsMoufangLoop, IsALoop and IsLeftAlternative );
# InstallTrueMethod( IsMoufangLoop, IsALoop and IsRightAlternative );
# InstallTrueMethod( IsMoufangLoop, IsALoop and HasLeftInverseProperty );
# InstallTrueMethod( IsMoufangLoop, IsALoop and HasRightInverseProperty );
# InstallTrueMethod( IsMoufangLoop, IsALoop and HasWeakInverseProperty );
# is implied by
# InstallTrueMethod( IsMiddleALoop, IsCommutative and IsLoop);
# InstallTrueMethod( IsLeftALoop, IsLeftBruckLoop );
# InstallTrueMethod( IsLeftALoop, IsLCCLoop );
# InstallTrueMethod( IsRightALoop, IsRightBruckLoop );
# InstallTrueMethod( IsRightALoop, IsRCCLoop );
# InstallTrueMethod( IsALoop, IsCommutative and IsMoufangLoop );
# InstallTrueMethod( IsALoop, IsLeftALoop and IsMiddleALoop );
# InstallTrueMethod( IsALoop, IsRightALoop and IsMiddleALoop );
# InstallTrueMethod( IsALoop, IsAssociative and IsLoop);
[ Dauer der Verarbeitung: 0.35 Sekunden
(vorverarbeitet)
]
|
