|
#############################################################################
##
## This file is part of GAP, a system for computational discrete algebra.
## This file's authors include J. D. Mitchell.
##
## Copyright of GAP belongs to its developers, whose names are too numerous
## to list here. Please refer to the COPYRIGHT file for details.
##
## SPDX-License-Identifier: GPL-2.0-or-later
##
## This file contains the declaration of operations for inverse semigroups.
##
InstallMethod(GeneratorsOfInverseSemigroup,
"for a group with known generators",
[IsGroup and HasGeneratorsOfGroup],
GeneratorsOfGroup);
InstallMethod(GeneratorsOfInverseMonoid,
"for a group with known generators",
[IsGroup and HasGeneratorsOfGroup],
GeneratorsOfGroup);
InstallImmediateMethod(GeneratorsOfSemigroup,
IsInverseSemigroup and HasGeneratorsOfInverseSemigroup, 0,
function(S)
local gens, out, x;
gens := GeneratorsOfInverseSemigroup(S);
out := ShallowCopy(gens);
for x in gens do
if not IsIdempotent(x) then
Add(out, x ^ -1);
fi;
od;
MakeImmutable(out);
return out;
end);
#
InstallMethod(IsInverseSubsemigroup, "for a semigroup and a semigroup",
[IsSemigroup, IsSemigroup],
function(s, t)
return IsSubsemigroup(s, t) and IsInverseSemigroup(t);
end);
#
InstallMethod(AsInverseMonoid, "for an inverse monoid",
[IsInverseMonoid], 100, IdFunc );
#
InstallMethod(AsInverseMonoid,
"for an inverse semigroup with known generators",
[IsInverseSemigroup and HasGeneratorsOfInverseSemigroup],
function(S)
local gens, pos;
if not (IsMultiplicativeElementWithOneCollection(S)
and One(S) <> fail and One(S) in S) then
return fail;
fi;
gens := GeneratorsOfInverseSemigroup(S);
if CanEasilyCompareElements(gens) then
pos := Position(gens, One(S));
if pos <> fail then
gens := ShallowCopy(gens);
Remove(gens, pos);
fi;
fi;
return InverseMonoid(gens);
end);
#
InstallOtherMethod(IsInverseSemigroup, "for an object", [IsObject], ReturnFalse);
#
InstallMethod(\.,"for an inverse semigroup with generators and pos int",
[IsInverseSemigroup and HasGeneratorsOfInverseSemigroup, IsPosInt],
function(s, n)
s:=GeneratorsOfInverseSemigroup(s);
n:=NameRNam(n);
n:=Int(n);
if n=fail or Length(s)<n then
Error("the second argument should be a positive integer not greater than",
" the number of generators of the semigroup in the first argument");
fi;
return s[n];
end);
#
InstallMethod(\., "for an inverse monoid with generators and pos int",
[IsInverseMonoid and HasGeneratorsOfInverseMonoid, IsPosInt],
function(s, n)
s:=GeneratorsOfInverseMonoid(s);
n:=NameRNam(n);
n:=Int(n);
if n=fail or Length(s)<n then
Error("usage: the second argument should be a pos int not greater than",
" the number of generators of the semigroup in the first argument");
fi;
return s[n];
end);
#
InstallGlobalFunction(InverseMonoid,
function(arg)
local out, i;
if Length(arg) = 0 or (Length(arg) = 1 and HasIsEmpty(arg[1])
and IsEmpty(arg[1])) then
ErrorNoReturn("Usage: cannot create an inverse monoid with no ",
"generators,");
fi;
out := [];
for i in [1 .. Length(arg)] do
if i = Length(arg) and IsRecord(arg[i]) then
if not IsGeneratorsOfInverseSemigroup(out) then
ErrorNoReturn("Usage: InverseMonoid(<gen>,...), ",
"InverseMonoid(<gens>), InverseMonoid(<D>),");
fi;
return InverseMonoidByGenerators(out, arg[i]);
elif IsMultiplicativeElementWithOne(arg[i]) or IsMatrix(arg[i]) then
Add(out, arg[i]);
elif IsListOrCollection(arg[i]) then
if IsGeneratorsOfInverseSemigroup(arg[i]) then
if HasGeneratorsOfInverseSemigroup(arg[i]) then
Append(out, GeneratorsOfInverseSemigroup(arg[i]));
elif HasGeneratorsOfSemigroup(arg[i]) or IsMagmaIdeal(arg[i]) then
Append(out, GeneratorsOfSemigroup(arg[i]));
elif IsList(arg[i]) then
Append(out, arg[i]);
else
Append(out, AsList(arg[i]));
fi;
elif not IsEmpty(arg[i]) then
ErrorNoReturn("Usage: InverseMonoid(<gen>,...), ",
"InverseMonoid(<gens>), InverseMonoid(<D>),");
fi;
else
ErrorNoReturn("Usage: InverseMonoid(<gen>,...), ",
"InverseMonoid(<gens>), InverseMonoid(<D>),");
fi;
od;
if not IsGeneratorsOfInverseSemigroup(out) then
ErrorNoReturn("Usage: InverseMonoid(<gen>,...), ",
"InverseMonoid(<gens>), InverseMonoid(<D>),");
fi;
return InverseMonoidByGenerators(out);
end);
#
InstallGlobalFunction(InverseSemigroup,
function(arg)
local out, i;
if Length(arg) = 0 or (Length(arg) = 1 and HasIsEmpty(arg[1])
and IsEmpty(arg[1])) then
ErrorNoReturn("Usage: cannot create an inverse semigroup with no ",
"generators,");
fi;
out := [];
for i in [1 .. Length(arg)] do
if i = Length(arg) and IsRecord(arg[i]) then
if not IsGeneratorsOfInverseSemigroup(out) then
ErrorNoReturn("Usage: InverseSemigroup(<gen>, ...), ",
"InverseSemigroup(<gens>), InverseSemigroup(<D>),");
fi;
return InverseSemigroupByGenerators(out, arg[i]);
elif IsMultiplicativeElement(arg[i]) or IsMatrix(arg[i]) then
Add(out, arg[i]);
elif IsListOrCollection(arg[i]) then
if IsGeneratorsOfInverseSemigroup(arg[i]) then
if HasGeneratorsOfInverseSemigroup(arg[i]) then
Append(out, GeneratorsOfInverseSemigroup(arg[i]));
elif HasGeneratorsOfSemigroup(arg[i]) or IsMagmaIdeal(arg[i]) then
Append(out, GeneratorsOfSemigroup(arg[i]));
elif IsList(arg[i]) then
Append(out, arg[i]);
else
Append(out, AsList(arg[i]));
fi;
elif not IsEmpty(arg[i]) then
ErrorNoReturn("Usage: InverseSemigroup(<gen>, ...), ",
"InverseSemigroup(<gens>), InverseSemigroup(<D>),");
fi;
else
ErrorNoReturn("Usage: InverseSemigroup(<gen>, ...), ",
"InverseSemigroup(<gens>), InverseSemigroup(<D>),");
fi;
od;
if not IsGeneratorsOfInverseSemigroup(out) then
ErrorNoReturn("Usage: InverseSemigroup(<gen >, ...), ",
"InverseSemigroup(<gens>), InverseSemigroup(<D>),");
fi;
return InverseSemigroupByGenerators(out);
end);
#
InstallMethod(InverseMonoidByGenerators,
[IsCollection],
function(gens)
local S, one, pos;
S := Objectify(NewType(FamilyObj(gens), IsMagmaWithOne
and IsInverseSemigroup
and IsAttributeStoringRep), rec());
gens := AsList(gens);
if CanEasilyCompareElements(gens) and IsFinite(gens)
and IsMultiplicativeElementWithOneCollection(gens) then
one := One(gens);
SetOne(S, one);
pos := Position(gens, one);
if pos <> fail then
SetGeneratorsOfInverseSemigroup(S, gens);
if Length(gens) = 1 then # Length(gens) <> 0 since One(gens) in gens
SetIsTrivial(S, true);
elif not IsPartialPermCollection(gens) or One(gens) =
One(gens{Concatenation([1 .. pos - 1], [pos + 1 .. Length(gens)])}) then
# if gens = [PartialPerm([1,2]), PartialPerm([1])], then removing the One
# = gens[1] from this, it is not possible to recreate the semigroup using
# Monoid(PartialPerm([1])) (since the One in this case is
# PartialPerm([1]) not PartialPerm([1,2]) as it should be.
gens := ShallowCopy(gens);
Remove(gens, pos);
fi;
SetGeneratorsOfInverseMonoid(S, gens);
else
SetGeneratorsOfInverseMonoid(S, gens);
gens := ShallowCopy(gens);
Add(gens, one);
SetGeneratorsOfInverseSemigroup(S, gens);
fi;
else
SetGeneratorsOfInverseMonoid(S, gens);
fi;
return S;
end);
#
InstallMethod(InverseSemigroupByGenerators, "for a collection",
[IsCollection],
function(gens)
local S, pos;
S := Objectify(NewType (FamilyObj(gens), IsMagma
and IsInverseSemigroup
and IsAttributeStoringRep), rec());
gens := AsList(gens);
SetGeneratorsOfInverseSemigroup(S, gens);
if IsMultiplicativeElementWithOneCollection(gens)
and CanEasilyCompareElements(gens)
and IsFinite(gens) then
pos := Position(gens, One(gens));
if pos <> fail then
SetFilterObj(S, IsMonoid);
if Length(gens) = 1 then # Length(gens) <> 0 since One(gens) in gens
SetIsTrivial(S, true);
elif not IsPartialPermCollection(gens) or One(gens) =
One(gens{Concatenation([1 .. pos - 1], [pos + 1 .. Length(gens)])}) then
# if gens = [PartialPerm([1,2]), PartialPerm([1])], then removing the One
# = gens[1] from this, it is not possible to recreate the semigroup using
# Monoid(PartialPerm([1])) (since the One in this case is
# PartialPerm([1]) not PartialPerm([1,2]) as it should be.
gens := ShallowCopy(gens);
Remove(gens, pos);
fi;
SetGeneratorsOfInverseMonoid(S, gens);
fi;
fi;
return S;
end);
#
InstallMethod(InverseSubsemigroupNC,
"for an inverse semigroup and collection",
[IsInverseSemigroup, IsCollection],
function(s, gens)
local t;
t:=InverseSemigroup(gens);
SetParent(t, s);
return t;
end);
#
InstallMethod(InverseSubsemigroup,
"for an inverse semigroup and collection",
[IsInverseSemigroup, IsCollection],
function(s, gens)
if ForAll(gens, x-> x in s) then
return InverseSubsemigroupNC(s, gens);
fi;
ErrorNoReturn("the specified elements do not belong to the first argument,");
end);
#
InstallMethod(InverseSubmonoidNC,
"for an inverse monoid and collection",
[IsInverseMonoid, IsCollection],
function(s, gens)
local t;
t:=InverseMonoid(gens);
SetParent(t, s);
return t;
end);
#
InstallMethod(InverseSubmonoid,
"for an inverse monoid and collection",
[IsInverseMonoid, IsCollection],
function(s, gens)
if ForAll(gens, x-> x in s) then
if One(s)<>One(gens) then
Append(gens, One(s));
fi;
return InverseSubmonoidNC(s, gens);
fi;
ErrorNoReturn("the specified elements do not belong to the first argument,");
end);
#
InstallMethod(IsSubsemigroup,
"for an inverse semigroup and inverse semigroup with generators",
[IsInverseSemigroup, IsInverseSemigroup and HasGeneratorsOfInverseSemigroup],
function(s, t)
return ForAll(GeneratorsOfInverseSemigroup(t), x-> x in s);
end);
#
InstallMethod(\=, "for an inverse semigroups with generators",
[IsInverseSemigroup and HasGeneratorsOfInverseSemigroup,
IsInverseSemigroup and HasGeneratorsOfInverseSemigroup],
function(s, t)
return ForAll(GeneratorsOfInverseSemigroup(s), x-> x in t)
and ForAll(GeneratorsOfInverseSemigroup(t), x-> x in s);
end);
InstallMethod( String,
"for a inverse semigroup",
[ IsInverseSemigroup ],
function( S )
return "InverseSemigroup( ... )";
end );
InstallMethod( PrintObj,
"for a inverse semigroup with known generators",
[ IsInverseSemigroup and HasGeneratorsOfInverseSemigroup ],
function( S )
Print( "InverseSemigroup( ", GeneratorsOfInverseSemigroup( S ), " )" );
end );
InstallMethod( String,
"for a inverse semigroup with known generators as an inverse semigroup",
[ IsInverseSemigroup and HasGeneratorsOfInverseSemigroup ],
function( S )
return STRINGIFY( "InverseSemigroup( ",
GeneratorsOfInverseSemigroup( S ), " )" );
end );
InstallMethod( String,
"for a inverse semigroup with known generators as a semigroup",
[ IsInverseSemigroup and HasGeneratorsOfSemigroup ],
function( S )
return STRINGIFY( "Semigroup( ",
GeneratorsOfSemigroup( S ), " )" );
end );
InstallMethod( PrintString,
"for a inverse semigroup with known generators",
[ IsInverseSemigroup and HasGeneratorsOfInverseSemigroup ],
function( S )
return PRINT_STRINGIFY( "InverseSemigroup( ",
GeneratorsOfInverseSemigroup( S ), " )" );
end );
InstallMethod( ViewString,
"for a inverse semigroup",
[ IsInverseSemigroup ],
function( S )
return "<inverse semigroup>" ;
end );
#InstallMethod( ViewString,
# "for a inverse semigroup with generators",
# [ IsInverseSemigroup and HasGeneratorsOfInverseSemigroup ],
# function( S )
# return STRINGIFY( "<inverse semigroup with ",
# Pluralize( Length( GeneratorsOfInverseSemigroup( S ) ), "generator" ),
# ">" );
# end );
#
InstallMethod( String,
"for a inverse monoid",
[ IsInverseMonoid ],
function( S )
return "InverseMonoid( ... )";
end );
InstallMethod( PrintObj,
"for a inverse monoid with known generators",
[ IsInverseMonoid and HasGeneratorsOfInverseMonoid ],
function( S )
Print( "InverseMonoid( ", GeneratorsOfInverseMonoid( S ), " )" );
end );
InstallMethod( String,
"for a inverse monoid with known generators as a monoid",
[ IsInverseMonoid and HasGeneratorsOfMonoid ],
function( S )
return STRINGIFY( "Monoid( ",
GeneratorsOfMonoid( S ), " )" );
end );
InstallMethod( String,
"for a inverse monoid with known generators as an inverse monoid",
[ IsInverseMonoid and HasGeneratorsOfInverseMonoid ],
function( S )
return STRINGIFY( "InverseMonoid( ",
GeneratorsOfInverseMonoid( S ), " )" );
end );
InstallMethod( PrintString,
"for a inverse monoid with known generators",
[ IsInverseMonoid and HasGeneratorsOfInverseMonoid ],
function( S )
return PRINT_STRINGIFY( "InverseMonoid( ",
GeneratorsOfInverseMonoid( S ), " )" );
end );
InstallMethod( ViewString,
"for a inverse monoid",
[ IsInverseMonoid ],
function( S )
return "<inverse monoid>" ;
end );
#InstallMethod( ViewString,
# "for a inverse monoid with generators",
# [ IsInverseMonoid and HasGeneratorsOfInverseMonoid ],
# function( S )
# return STRINGIFY( "<inverse monoid with ",
# Pluralize( Length( GeneratorsOfInverseMonoid( S ) ), "generator" ), ">" );
# end );
#
InstallMethod( AsInverseSemigroup,
"for an inverse semigroup",
[ IsInverseSemigroup ], 100,
IdFunc );
InstallMethod( AsInverseMonoid,
"for an inverse monoid",
[ IsInverseMonoid ], 100,
IdFunc );
#
InstallMethod( IsRegularSemigroupElement,
"for an inverse semigroup", IsCollsElms,
[IsInverseSemigroup, IsAssociativeElement],
function(s, x)
return x in s;
end);
[ Dauer der Verarbeitung: 0.9 Sekunden
(vorverarbeitet)
]
|
