Quelle fitting.gi Sprache: unbekannt

#############################################################################
##
##  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
##

Quelle fitting.gi Sprache: unbekannt

[ Dauer der Verarbeitung: 0.35 Sekunden (vorverarbeitet) ]