#############################################################################
##
## fitting.gi CRISP Burkhard Höfling
##
## Copyright © 2000 Burkhard Höfling
##
#############################################################################
##
#M FittingClass(<rec>)
##
InstallMethod(FittingClass, true, [IsRecord], 0,
function(record)
local F, r;
r := ShallowCopy(record);
F := NewClass("FittingClass",
IsGroupClass and IsClassByPropertyRep,
rec(definingAttributes :=
[ ["in", MemberFunction],
["rad", RadicalFunction],
["inj", InjectorFunction]]));
SetIsFittingClass(F, true);
if IsBound(r.char) then
SetCharacteristic(F, r.char);
Unbind(r.char);
fi;
InstallDefiningAttributes(F, r);
return F;
end);
#############################################################################
##
#M ViewObj(<fit>)
##
InstallMethod(ViewObj, "for Fitting class", true,
[IsFittingClass and IsClassByPropertyRep], 0,
function(C)
Print("FittingClass(");
ViewDefiningAttributes(C);
Print(")");
end);
#############################################################################
##
#M PrintObj(<fit>)
##
InstallMethod(PrintObj, "for Fitting class", true,
[IsFittingClass and IsClassByPropertyRep], 0,
function(C)
Print("FittingClass( rec(");
PrintDefiningAttributes(C);
Print("))");
end);
#############################################################################
##
#M IsMemberOp(<grp>, <fit>)
##
InstallMethod(IsMemberOp, "if radical is known", true,
[IsGroup, IsFittingClass and HasRadicalFunction], 1,
# radical function is usually faster than injector
function(G, C)
if HasMemberFunction(C) then
TryNextMethod();
else
return IsSubgroup(RadicalFunction(C)(G), G);
fi;
end);
#############################################################################
##
#M IsMemberOp(<grp>, <fit>)
##
InstallMethod(IsMemberOp, "if injector is known", true,
[IsGroup, IsFittingClass and HasInjectorFunction], 0,
function(G, C)
if HasMemberFunction(C) then
TryNextMethod();
else
return IsSubgroup(InjectorFunction(C)(G), G);
fi;
end);
#############################################################################
##
#R IsFittingProductRep(<cl>)
##
## classes which are defined as Fitting product
##
DeclareRepresentation("IsFittingProductRep",
IsClass and IsGroupClass and IsFittingClass and
IsComponentObjectRep and IsAttributeStoringRep,
["classId", "bot", "top"]);
#############################################################################
##
#M FittingProduct(<bot>, <top>)
##
InstallMethod(FittingProduct, "of two Fittng classes", true,
[IsFittingClass, IsFittingClass], 0,
function(B, T)
return NewClass("Fitting product fam", IsFittingProductRep,
rec(bot := B, top := T));
end);
#############################################################################
##
#M ViewObj
##
InstallMethod(ViewObj, "for Fitting product", true, [IsFittingProductRep], 0,
function(C)
Print("FittingProduct(");
ViewObj(C!.bot);
Print(", ");
ViewObj(C!.top);
Print(")");
end);
#############################################################################
##
#M PrintObj
##
InstallMethod(PrintObj, "for Fitting product", true, [IsFittingProductRep], 0,
function(C)
Print("FittingProduct(");
PrintObj(C!.bot);
Print(", ");
PrintObj(C!.top);
Print(")");
end);
#############################################################################
##
#M IsMemberOp(<prod>)
##
InstallMethod(IsMemberOp, "for Fitting product", true,
[IsGroup, IsFittingProductRep], 0,
function(G, C)
return G/ Radical(G, C!.bot) in C!.top;
end);
#############################################################################
##
#M Characteristic(<bot>, <top>)
##
InstallMethod(Characteristic, "for Fitting product", true,
[IsFittingProductRep], 0,
function(C)
return Union(Characteristic(C!.top), Characteristic(C!.bot));
end);
#############################################################################
##
#M FittingProduct(<bot>, <top>)
##
InstallMethod(FittingProduct,
"for Fitting formation - use FormationProduct", true,
[IsFittingFormation, IsFittingFormation], 0,
FormationProduct);
#############################################################################
##
#R IsFittingSetRep
##
DeclareRepresentation("IsFittingSetRep",
IsClassByPropertyRep and IsMultiplicativeElementCollColl,
["classId", "group"]);
#############################################################################
##
#M FittingSet(<grp>, <rec>)
##
InstallMethod(FittingSet, true, [IsGroup, IsRecord], 0,
function(G, r)
local F;
F := NewClass(CollectionsFamily(FamilyObj(G)), IsFittingSetRep,
rec(group := G,
definingAttributes :=
[ ["in", MemberFunction],
["rad", RadicalFunction],
["inj", InjectorFunction]]));
InstallDefiningAttributes(F, r);
return F;
end);
#############################################################################
##
#M IsFittingSet(<grp>, <class>)
##
InstallMethod(IsFittingSet, " for IsFittingSetRep",
function(G, C) return IsIdenticalObj(CollectionsFamily(G), C); end,
[IsGroup, IsFittingSetRep], 3,
function(G, C)
return IsSubgroup(C!.group, G);
end);
#############################################################################
##
#M IsFittingSet(<grp>, <class>)
##
InstallMethod(IsFittingSet, " for Fitting class",
true,
[IsGroup, IsFittingClass], 0,
function(G, C)
return true;
end);
#############################################################################
##
#M ViewObj(<fit>)
##
InstallMethod(ViewObj, "for Fitting set", true,
[IsFittingSetRep and IsClassByPropertyRep], 0,
function(C)
Print("FittingSet(", C!.group, ", rec(");
ViewDefiningAttributes(C);
Print("))");
end);
#############################################################################
##
#M PrintObj(<fit>)
##
InstallMethod(PrintObj, "for Fitting set", true,
[IsFittingSetRep and IsClassByPropertyRep], 0,
function(C)
Print("FittingSet(", C!.group, ", rec(");
PrintDefiningAttributes(C);
Print("))");
end);
#############################################################################
##
#M IsMemberOp(<grp>, <fitset>)
##
InstallMethod(IsMemberOp, "if radical is known",
function(G, C) return IsIdenticalObj(CollectionsFamily(G), C); end,
[IsGroup, IsFittingSetRep and HasRadicalFunction], 1, # radical function is usually faster
than injector
function(G, C)
if HasMemberFunction(C) then
TryNextMethod();
else
return IsSubgroup(RadicalFunction(C)(G), G);
fi;
end);
#############################################################################
##
#M IsMemberOp(<grp>, <fitset>)
##
InstallMethod(IsMemberOp, "for FittingSetRep with inj function",
function(G, C) return IsIdenticalObj(CollectionsFamily(G), C); end,
[IsGroup, IsFittingSetRep and HasInjectorFunction], 0,
function(G, C)
if HasMemberFunction(C) then
TryNextMethod();
else
return IsSubgroup(InjectorFunction(C)(G), G);
fi;
end);
#############################################################################
##
#M Intersection2(<fitset>, <fit>)
##
InstallMethod(Intersection2, "for Fitting set and Fitting class", true,
[IsFittingSetRep, IsFittingClass], 0,
function(F1, F2)
local F;
F := FittingSet(F1!.group,
rec(\in := x -> x in F1 and x in F2,
rad := G -> Radical(Radical(G, F2), F1)));
return F;
end);
#############################################################################
##
#M Intersection2(<fit>, <fitset>)
##
InstallMethod(Intersection2, "for Fitting class and Fitting set",
IsIdenticalObj,
[IsFittingClass, IsFittingSetRep], 0,
function(F1, F2)
return Intersection2(F2, F1);
end);
#############################################################################
##
#M Intersection2(<fitset1>, <fitset2>)
##
InstallMethod(Intersection2, "for Fitting sets", IsIdenticalObj,
[IsFittingSetRep, IsFittingSetRep], 0,
function(F1, F2)
local F;
F := FittingSet(Intersection(F1!.group, F2!.group),
rec(\in := x -> x in F1 and x in F2,
rad := G -> Radical(Radical(G, F2), F1)));
return F;
end);
#############################################################################
##
#M PreImageFittingSet(<alpha>, <fitset>)
##
## return Fitting set of preimage
##
InstallMethod(PreImageFittingSet, "for Fitting set",
function(famalpha, famF)
return IsIdenticalObj(FamilyRange(famalpha),
ElementsFamily(ElementsFamily(famF)));
end,
[IsGroupHomomorphism, IsFittingSetRep], 0,
function(alpha, F)
if not IsFittingSet(ImagesSource(alpha), F) then
Error("F must be a Fitting set of the image of alpha");
else
return FittingSet(Source(alpha), rec(
inj := G ->PreImagesSet(alpha,
Injector(ImagesSet(alpha, G), F))));
fi;
end);
#############################################################################
##
#M PreImageFittingSet(<alpha>, <fitset>)
##
## return Fitting set of preimage of an isomorphism
##
InstallMethod(PreImageFittingSet, "for Fitting set - injective case",
function(famalpha, famF)
return IsIdenticalObj(FamilyRange(famalpha),
ElementsFamily(ElementsFamily(famF)));
end,
[IsGroupHomomorphism and IsInjective, IsFittingSetRep], 0,
function(alpha, F)
if not IsFittingSet(ImagesSource(alpha), F) then
Error("F must be a Fitting set of the image of alpha");
else
return FittingSet(Source(alpha), rec(
\in := G ->ImagesSet(alpha, G) in F,
rad := G ->PreImagesSet(alpha,
Radical(ImagesSet(alpha, G), F)),
inj := G ->PreImagesSet(alpha,
Injector(ImagesSet(alpha, G), F))));
fi;
end);
#############################################################################
##
#M ImageFittingSet(<alpha>, <fitset>)
##
## return Fitting set of image
##
InstallMethod(ImageFittingSet, "for Fitting set",
function(famalpha, famF)
return IsIdenticalObj(FamilySource(famalpha),
ElementsFamily(ElementsFamily(famF)));
end,
[IsGroupHomomorphism, IsFittingSetRep], 0,
function(alpha, F)
if not IsFittingSet(Source(alpha), F) then
Error("F must be a Fitting set of the preimage of alpha");
else
return FittingSet(ImagesSource(alpha), rec(
inj := G ->ImagesSet(alpha,
Injector(PreImagesSet(alpha, G), F))));
fi;
end);
#############################################################################
##
#M ImageFittingSet(<alpha>, <fitset>)
##
## return Fitting set of image when alpha is injective
##
InstallMethod(ImageFittingSet, "for Fitting set - injective case",
function(famalpha, famF)
return IsIdenticalObj(FamilySource(famalpha),
ElementsFamily(ElementsFamily(famF)));
end,
[IsGroupHomomorphism and IsInjective, IsFittingSetRep], 0,
function(alpha, F)
if not IsFittingSet(Source(alpha), F) then
Error("F must be a Fitting set of the preimage of alpha");
else
return FittingSet(ImagesSet(alpha), rec(
\in := G ->PreImagesSet(alpha, G) in F,
rad := G ->ImagesSet(alpha,
Radical(PreImagesSet(alpha, G), F)),
inj := G ->ImagesSet(alpha,
Injector(PreImagesSet(alpha, G), F))));
fi;
end);
#############################################################################
##
#M PreImageFittingSet(<alpha>, <fit>)
##
## return Fitting set of preimage
##
InstallMethod(PreImageFittingSet, "for Fitting class", true,
[IsGroupHomomorphism, IsFittingClass], 0,
function(alpha, F)
return FittingSet(Source(alpha), rec(
inj := G ->PreImagesSet(alpha,
Injector(ImagesSet(alpha, G), F))));
end);
#############################################################################
##
#M PreImageFittingSet(<alpha>, <fit>)
##
## return Fitting set of preimage of an isomorphism
##
InstallMethod(PreImageFittingSet, "for Fitting class - injective case", true,
[IsGroupHomomorphism and IsInjective, IsFittingClass], 0,
function(alpha, F)
return FittingSet(Source(alpha), rec(
\in := G ->ImagesSet(alpha, G) in F,
rad := G ->PreImagesSet(alpha,
Radical(ImagesSet(alpha, G), F)),
inj := G ->PreImagesSet(alpha,
Injector(ImagesSet(alpha, G), F))));
end);
#############################################################################
##
#M ImageFittingSet(<alpha>, <fitset>)
##
## return Fitting set of image
##
InstallMethod(ImageFittingSet, "for Fitting class", true,
[IsGroupHomomorphism, IsFittingClass], 0,
function(alpha, F)
return FittingSet(Image(alpha), rec(
inj := G ->ImagesSet(alpha,
Injector(PreImagesSet(alpha, G), F))));
end);
#############################################################################
##
#M ImageFittingSet(<alpha>, <fitset>)
##
## return Fitting set of image when alpha is injective
##
InstallMethod(ImageFittingSet, "for Fitting class - injective case", true,
[IsGroupHomomorphism and IsInjective, IsFittingClass], 0,
function(alpha, F)
return FittingSet(Image(alpha), rec(
\in := G ->PreImagesSet(alpha, G) in F,
rad := G ->ImagesSet(alpha,
Radical(PreImagesSet(alpha, G), F)),
inj := G ->ImagesSet(alpha,
Injector(PreImagesSet(alpha, G), F))));
end);
############################################################################
##
#E
##
