Quelle  mwo.gi   Sprache: Shell

############################################################################# 
## 
#W  mwo.gi                 GAP4 package `groupoids'             Chris Wensley 
##
##  This file contains the declarations of elements, magma, etc., and their 
##  families in the case of many objects.  So each algebraic structure comes 
##  with a set of objects, and each element $e$ has a tail object $te$ and a 
##  head object $he$, and multiplies partially if composable: on the left 
##  with those elements in its family which have head $te$, and on the right 
##  with those elements of its family which have tail $he$.  Non-composable 
##  elements return $fail$ when multiplied. 
##  

###########################  DOMAIN WITH OBJECTS  ########################### 

############################################################################# 
## 
#M  KindOfDomainWithObjects( <dwo> ) 
##
InstallMethod( KindOfDomainWithObjects, "for a list of domains with objects", 
    true, [ IsList ], 0, 
function( pieces ) 

    local kind; 

    ## kind:  1=gpd, 2=mon, 3=sgp, 4=mgm, 5=dom 
    kind := 0; 
    if ForAll( pieces, p -> ( FamilyObj(p) =  IsGroupoidFamily ) ) then 
        kind := 1; 
    elif ForAll( pieces, p -> ( ( FamilyObj(p) = IsMonoidWithObjectsFamily ) 
                             or ( FamilyObj(p) = IsGroupoidFamily ) ) ) then
        kind := 2; 
    elif ForAll( pieces, p -> ( ( FamilyObj(p) = IsSemigroupWithObjectsFamily ) 
                             or ( FamilyObj(p) = IsMonoidWithObjectsFamily ) 
                             or ( FamilyObj(p) = IsGroupoidFamily ) ) ) then 
        kind := 3; 
    elif ForAll( pieces, p -> 
        ( "IsMagmaWithObjects" in CategoriesOfObject(p) ) ) then 
        kind := 4; 
    elif ForAll( pieces, p -> 
        ( "IsDomainWithObjects" in CategoriesOfObject(p) ) ) then 
        kind := 5; 
    else 
        Info( InfoGroupoids, 2, "just an ordinary list?" ); 
    fi; 
    return kind; 
end );

#####################  MULT ELTS WITH OBJECTS  ############################## 

############################################################################# 
## 
#M  Arrow( <mwo>, <elt>, <tail>, <head> ) 
#M  ArrowNC( <mwo> <isgpdelt>, <elt>, <tail>, <head> ) 
##
InstallMethod( ArrowNC, 
    "for mwo, boolean, element, tail and head", true,  
    [ IsMagmaWithObjects, IsBool, IsMultiplicativeElement, IsObject, IsObject ],
    0, 
function( mwo, isge, e, t, h ) 

    local obs, elt, fam;

    Info( InfoGroupoids, 3, "standard method for ArrowNC" );
    if isge then 
        fam := IsGroupoidElementFamily; 
        elt := Objectify( IsGroupoidElementType, [ mwo, e, t, h ] );
    else 
        fam := IsMultiplicativeElementWithObjectsFamily; 
        elt := Objectify( IsMultiplicativeElementWithObjectsType,
                   [ mwo, e, t, h ] ); 
    fi; 
    return elt; 
end ); 

InstallMethod( Arrow, 
    "for general magma with objects, element, tail and head", true, 
    [ IsMagmaWithObjects, IsMultiplicativeElement, IsObject, IsObject ], 0, 
function( mwo, e, t, h ) 

    local piece, obs, fam, mag, pwo, pos, homset, pose; 

    if IsSinglePiece( mwo ) then 
        piece := mwo; 
    else 
        piece := PieceOfObject( mwo, t );
    fi;
    mag := piece!.magma; 
    if not ( e in mag ) then 
        Error( "<e> not in magma <mag>," ); 
    fi;
    obs := piece!.objects; 
    if not ( ( t in obs ) and ( h in obs ) ) then  
        Error( "<t> and <h> must be objects in <piece>," ); 
    fi;
    if not IsDirectProductWithCompleteDigraph( piece ) then 
        if not IsBound( piece!.table ) then 
            TryNextMethod(); 
        fi;
        pos := [ Position( obs, t ), Position( obs, h ) ]; 
        if not HasMultiplicationTable( mag ) then 
            Error( "expecting magma defined by multiplication table," ); 
        fi; 
        homset := piece!.table[pos[1]][pos[2]]; 
        pose := Position( GeneratorsOfMagma( mag ), e ); 
        if not ( pose in homset ) then 
            Error( "(e : t -> h) not an element in <piece>," ); 
        fi;   
    fi; 
    return ArrowNC( mwo, false, e, t, h ); 
end );

#############################################################################
## 
#M  ElementOfArrow
#M  TailOfArrow
#M  HeadOfArrow
#M  GroupoidOfArrow
##
InstallMethod( ElementOfArrow, "generic method for magma with objects element", 
    true, [ IsMultiplicativeElementWithObjects ], 0, e -> e![2] ); 

InstallMethod( TailOfArrow, "generic method for magma with objects element", 
    true, [ IsMultiplicativeElementWithObjects ], 0, e -> e![3] ); 

InstallMethod( HeadOfArrow, "generic method for magma with objects element", 
    true, [ IsMultiplicativeElementWithObjects ], 0, e -> e![4] ); 

InstallMethod( GroupoidOfArrow, "generic method for magma with objects element", 
    true, [ IsMultiplicativeElementWithObjects ], 0, e -> e![1] ); 

#############################################################################
##
#M  String, ViewString, PrintString, ViewObj, PrintObj 
##  . . . . . . . . . . . . . . . . . . for elements in a magma with objects 
##
InstallMethod( String, "for an element in a magma with objects", true, 
    [ IsMultiplicativeElementWithObjects ], 0, 
function( e ) 
    return( STRINGIFY( "[", String( e![2] ), " : ", String( e![3] ), 
                       " -> ", String( e![4] ), "]" ) ); 
end );

InstallMethod( ViewString, "for an element in a magma with objects", true, 
    [ IsMultiplicativeElementWithObjects ], 0, String ); 

InstallMethod( PrintString, "for an element in a magma with objects", true, 
    [ IsMultiplicativeElementWithObjects ], 0, String ); 

InstallMethod( ViewObj, "for an element in a magma with objects", true, 
    [ IsMultiplicativeElementWithObjects ], 0, PrintObj ); 

InstallMethod( PrintObj, "for an element in a magma with objects",
    [ IsMultiplicativeElementWithObjects ],
function ( e )
    Print( "[", e![2], " : ", e![3], " -> ", e![4], "]" );
end );

InstallMethod( ViewObj, "for an element in a magma with objects",
    [ IsMultiplicativeElementWithObjects ], PrintObj );

#############################################################################
##
#M  \=( <e1>, <e2> ) . . . . . . equality of elements in a magma with objects
##
InstallMethod( \=, "for two multiplicative elements with objects", 
    IsIdenticalObj, [ IsMultiplicativeElementWithObjects, 
                      IsMultiplicativeElementWithObjects ], 0,
function( e1, e2 )
    return ForAll( [1..4], i -> ( e1![i] = e2![i] ) ); 
end );

#############################################################################
##
#M  \<( <e1>, <e2> ) . . . . . . equality of elements in a magma with objects
##
InstallMethod( \<, "for two multiplicative elements with objects", 
    IsIdenticalObj, [ IsMultiplicativeElementWithObjects, 
                      IsMultiplicativeElementWithObjects ], 0,
function( e1, e2 )
    if ( e1![1] <> e2![1] ) then
        Error( "e1, e2 belong to different mwos" );
    fi;
    if ( e1![3] < e2![3] ) then 
        return true; 
    elif ( (e1![3] = e2![3]) and (e1![4] < e2![4]) ) then 
        return true; 
    elif ( (e1![3] = e2![3]) and (e1![4] = e2![4]) and (e1![2] < e2![2]) ) then 
        return true; 
    else 
        return false; 
    fi;
end );

############################################################################# 
## 
#M  \*( e1, e2 ) . . . . . . composition of elements in a magma with objects 
## 
InstallMethod( \*, "for two elements in a magma with objects", IsIdenticalObj,
    [IsMultiplicativeElementWithObjects, IsMultiplicativeElementWithObjects], 
    0, 
function( e1, e2 ) 

    local prod; 

    if ( e1![1] <> e2![1] ) then
        Error( "e1, e2 belong to different mwos" );
    fi;
    ## elements are composable? 
    if ( e1![4] = e2![3] ) then 
        return ArrowNC( e1![1], false, e1![2]*e2![2], e1![3], e2![4] ); 
    else 
        return fail; 
    fi;  
end );

############################################################################# 
## 
#M  \^( e, p ) . . . . . . power (inverse) of element in a magma with objects 
## 
InstallMethod( \^, "for an element in a magma with objects and a PosInt", 
    true, [ IsMultiplicativeElementWithObjects, IsPosInt ], 0, 
function( e, p ) 
    ##  should be able to invert an identity element 
    ##  groupoids use their own method 
    if ( e![4] = e![3] ) then 
        return ArrowNC( e![1], false, e![2]^p, e![3], e![4] ); 
    else 
        return fail; 
    fi;  
end );

#############################################################################
##
#M  Order( <e> )  . . . . . . . . . . . . . . . . . . . . . of an mwo element
##
InstallOtherMethod( Order, "for a multiplicative element with objects", true,
    [ IsMultiplicativeElementWithObjects ], 0,
function( e ) 

    local ord;

    if not ( e![3] = e![4] ) then
        Error( "tail of e <> head of e," );
    fi;
    return Order( e![2] );
end );


################################  MAGMAS  ################################### 

############################################################################# 
## 
#F  MagmaWithObjects( <mag>, <obs> ) 
##
InstallGlobalFunction( MagmaWithObjects, function( arg ) 

    local obs, mag;

    # list of objects and a magma 
    if ( ( Length(arg) = 2 ) and IsMagma( arg[1] ) and IsSet( arg[2] ) ) then 
        mag := arg[1]; 
        obs := arg[2]; 
        if ( HasIsGeneratorsOfMagmaWithInverses( mag ) 
            and IsGeneratorsOfMagmaWithInverses( mag ) 
            and HasIsAssociative( mag ) and IsAssociative( mag ) ) then 
            Info( InfoGroupoids, 1, "SinglePieceGroupoid:-" );
            return SinglePieceGroupoid( mag, obs ); 
        elif ( HasIsMonoid( mag ) and IsMonoid( mag ) ) then 
            Info( InfoGroupoids, 1, "SinglePieceMonoidWithObjects:-" ); 
            return SinglePieceMonoidWithObjects( mag, obs ); 
        elif ( HasIsSemigroup( mag ) and IsSemigroup( mag ) ) then 
            Info( InfoGroupoids, 1, "SinglePieceSemigroupWithObjects:-" ); 
            return SinglePieceSemigroupWithObjects( mag, obs ); 
        else  ## it's just a magma 
            Info( InfoGroupoids, 1, "SinglePieceMagmaWithObjects:-" );
            return SinglePieceMagmaWithObjects( mag, obs ); 
        fi; 
    else 
        Error( "Current usage: MagmaWithObjects( <mag>, <obs> )," ); 
    fi; 
end ); 

############################################################################# 
## 
#M  SinglePieceMagmaWithObjects( <mag>, <obs> ) . . . . for magma and objects 
##
InstallMethod( SinglePieceMagmaWithObjects, 
    "for magma, objects", true, [ IsMagma, IsCollection ], 0, 
function( mag, obs ) 

    local cf, one, r, gens, mwo, fmwo, cmwo, isa, isc; 

    mwo := rec( objects := obs, magma := mag); 
    ObjectifyWithAttributes( mwo, IsMagmaWithObjectsType, 
        IsAssociative, IsAssociative( mag ), 
        IsCommutative, IsCommutative( mag ), 
        IsFinite, IsFinite( mag ), 
        IsSinglePieceDomain, true, 
        IsDirectProductWithCompleteDigraphDomain, true );
    gens := GeneratorsOfMagmaWithObjects( mwo );
    return mwo; 
end ); 

#############################################################################
##
#M  \=( <m1>, <m2> )  . . . . . . . test if two magmas with objects are equal
##
InstallMethod( \=, "for magmas with objects", IsIdenticalObj,
    [ IsMagmaWithObjects, IsMagmaWithObjects ], 0, 
function ( m1, m2 ) 

    local i, p1, p2;

    if ( IsSinglePiece(m1) and IsSinglePiece(m2) ) then 
        return ( ( m1!.objects=m2!.objects ) and ( m1!.magma=m2!.magma ) ); 
    elif ( IsSinglePiece(m1) or IsSinglePiece(m2) ) then 
        return false; 
    else 
        p1 := Pieces( m1 ); 
        p2 := Pieces( m2 ); 
        if not ( Length( p1 ) = Length( p2 ) ) then 
            return false; 
        else 
            for i in [1..Length( p1 )] do 
                if ( p1[i] <> p2[i] ) then 
                    return false; 
                fi; 
            od; 
            return true; 
        fi; 
    fi;
end );

#############################################################################
##
#M  \in( <elt>, <mwo> ) . . . . test if an element is in a magma with objects 
##

InstallMethod( \in, "for mwo element and a standard magma with objects", true, 
    [ IsMultiplicativeElementWithObjects, 
      IsMagmaWithObjects and IsSinglePiece ], 0,
function( e, mwo ) 
    return ( e![1] = mwo );
end ); 

InstallMethod( \in, "for mwo element and a union of pieces", true, 
    [ IsMultiplicativeElementWithObjects, IsMagmaWithObjects and HasPieces ], 0,
function( e, mwo )
    return e in PieceOfObject( mwo, e![3] ); 
end );

#############################################################################
##
#M  Size 
##
InstallOtherMethod( Size, "generic method for a magma with objects", true,
    [ IsMagmaWithObjects ], 0,
function( mwo )

    local p, s;

    if ( HasIsDirectProductWithCompleteDigraph( mwo ) and 
            IsDirectProductWithCompleteDigraph( mwo ) ) then 
        return Size( mwo!.magma ) * Length( mwo!.objects )^2; 
    elif ( HasIsDiscreteDomainWithObjects( mwo ) and 
              IsDiscreteDomainWithObjects( mwo ) ) then 
        return Size( mwo!.magma ) * Length( mwo!.objects ); 
    elif ( HasIsSinglePieceDomain( mwo ) and 
              IsSinglePieceDomain( mwo ) ) then 
        return Size( mwo!.magma ) * Length( mwo!.objects )^2;
Print("reached here\n");
    elif HasPieces( mwo ) then 
        s := 0; 
        for p in Pieces( mwo ) do 
            s := s + Size(p); 
        od;
        return s; 
    else 
        TryNextMethod();  
    fi;
end );

#############################################################################
##
#M  String, ViewString, PrintString, ViewObj, PrintObj 
##  . . . . . . . . . . . . . . . . . . . . . . . . for a magma with objects 
##
InstallMethod( String, "for a magma with objects", true, 
    [ IsMagmaWithObjects ], 0, 
function( mwo ) 

    local kind; 

    kind := KindOfDomainWithObjects( [ mwo ] ); 
    if ( kind = 1 ) then 
        return( STRINGIFY( "groupoid" ) ); 
    elif ( kind = 2 ) then 
        return( STRINGIFY( "monoid with objects" ) ); 
    elif ( kind = 3 ) then 
        return( STRINGIFY( "semigroup with objects" ) ); 
    elif ( kind = 4 ) then 
        return( STRINGIFY( "magma with objects" ) ); 
    else 
        return( STRINGIFY( "domain with objects" ) ); 
    fi; 
end );

InstallMethod( ViewString, "for an element in a magma with objects", true, 
    [ IsMultiplicativeElementWithObjects ], 0, String ); 

InstallMethod( PrintString, "for an element in a magma with objects", true, 
    [ IsMultiplicativeElementWithObjects ], 0, String ); 

InstallMethod( ViewObj, "for an element in a magma with objects", true, 
    [ IsMultiplicativeElementWithObjects ], 0, PrintObj ); 

InstallMethod( ViewObj, "for a single piece magma with objects", true, 
    [ IsSinglePiece ], 0,   
function( mwo )

    local kind; 

    kind := KindOfDomainWithObjects( [ mwo ] ); 
    if ( kind = 1 ) or ( kind = 5 ) then 
        Print( "#I  should be using special groupoid method!\n" ); 
    elif ( kind = 2 ) then 
        Print( "monoid with objects :-\n" ); 
    elif ( kind = 3 ) then 
        Print( "semigroup with objects :-\n" ); 
    elif ( kind = 4 ) then 
        Print( "magma with objects :-\n" ); 
    else 
        Print( "not yet implemented for general domains with objects\n" ); 
    fi; 
    Print( "    magma = ", mwo!.magma, "\n" ); 
    Print( "  objects = ", mwo!.objects, "\n" ); 
end );

InstallMethod( PrintObj, "for a single piece magma with objects", true, 
    [ IsSinglePiece ], 0, 
function( mwo )

    local kind; 

    kind := KindOfDomainWithObjects( [ mwo ] ); 
    if ( kind = 1 ) or ( kind = 5 ) then 
        Print( "#I  should be using special groupoid method!\n" ); 
    elif ( kind = 2 ) then 
        Print( "monoid with objects :-\n" ); 
    elif ( kind = 3 ) then 
        Print( "semigroup with objects :-\n" ); 
    elif ( kind = 4 ) then 
        Print( "magma with objects :-\n" ); 
    else 
        Print( "not yet implemented for general domains with objects\n" ); 
    fi; 
    Print( "    magma = ", mwo!.magma, "\n" ); 
    Print( "  objects = ", mwo!.objects, "\n" ); 
end );

InstallMethod( ViewObj, "for more than one piece", true, 
    [ IsDomainWithObjects and IsPiecesRep ], 10,   
function( dwo )

    local i, pieces, np, kind; 

    pieces := Pieces( dwo ); 
    np := Length( pieces ); 
    kind := KindOfDomainWithObjects( Pieces( dwo ) ); 
    if (kind=1) then Print( "groupoid" );  
      elif (kind=2) then Print( "monoid with objects" ); 
      elif (kind=3) then Print( "semigroup with objects" ); 
      elif (kind=4) then Print( "magma with objects" ); 
      elif (kind=5) then Print( "double groupoid" ); 
      elif (kind=0) then Error( "invalid domain with objects," ); 
    fi;
    Print( " having ", np, " pieces :-\n" ); 
    for i in [1..np] do 
        Print( i, ": ", pieces[i] ); 
        if HasName( pieces[i] ) then 
            Print( "\n" ); 
        fi; 
    od; 
end ); 

InstallMethod( PrintObj, "for more than one piece", true, 
    [ IsMagmaWithObjects and IsPiecesRep ], 0,   
function( mwo )

    local i, pieces, np; 

    pieces := Pieces( mwo ); 
    np := Length( pieces ); 
    Print( "domain with objects having ", np, " pieces :-\n" ); 
    for i in [1..np] do 
        Print( pieces[i] ); 
        if HasName( pieces[i] ) then 
            Print( "\n" ); 
        fi; 
    od; 
end ); 

##############################################################################
##
#M  Display( <mwo> ) . . . . . . . . . . . . . .  display a magma with objects
##
InstallMethod( Display, "for a mwo", true, [ IsMagmaWithObjects ], 0, 
function( mwo )
    
    local comp, c, i, m, len;

    if IsSinglePiece( mwo ) then 
        if IsDirectProductWithCompleteDigraph( mwo ) then 
            Print( "Single constituent magma with objects: " );
            if HasName( mwo ) then
                Print( mwo );
            fi;
            Print( "\n" ); 
            Print( "  objects: ", mwo!.objects, "\n" );
            m := mwo!.magma;
            Print( "    magma: " );
            if HasName( m ) then
                Print( m, " = <", GeneratorsOfMagma( m ), ">\n" );
            else
                Print( m, "\n" );
            fi;
        else
            TryNextMethod(); 
        fi; 
    else
        comp := Pieces( mwo );
        len := Length( comp );
        Print( "Magma with objects with ", len, " pieces:\n" );
        for i in [1..len] do
            c := comp[i];
            if IsDirectProductWithCompleteDigraph( c ) then 
                Print( "< objects: ", c!.objects, "\n" );
                m := c!.magma;
                Print( "    magma: " );
                if HasName( m ) then
                    Print( m, " = <", GeneratorsOfMagma( m ), "> >\n" );
                else
                    Print( m, " >\n" );
                fi;
            else 
                TryNextMethod(); 
            fi; 
        od;
    fi;
end );

#############################################################################
##
#M  RootObject( <mwo> )      for a connected or many-piece magma with objects
##
InstallMethod( RootObject, "for a single piece mwo", true, 
    [ IsSinglePiece ], 0,
function( mwo )
    return mwo!.objects[1]; 
end ); 

InstallOtherMethod( RootObject, "for a mwo with pieces", true, 
    [ IsDomainWithObjects and IsPiecesRep ], 0,
function( mwo )
    Print( "#I only a single piece magma with objects has a root object\n" ); 
    return fail; 
end ); 

#############################################################################
##
#M  GeneratorsOfMagmaWithObjects( <mwo> )  for a connected magma with objects 
#M  GeneratorsOfSemigroupWithObjects( <swo> )
#M  GeneratorsOfMonoidWithObjects( <mwo> )
##
InstallMethod( GeneratorsOfMagmaWithObjects, "for a single piece mwo", 
    true, [ IsSinglePiece ], 0,
function( mwo )

    local obs, nobs, o1, m, mgens, kind, gens, i, j, k, g; 

    obs := mwo!.objects;
    nobs := Length( obs );
    o1 := obs[1];
    m := mwo!.magma; 
    kind := 1; 
    if ( "IsGroupoid" in CategoriesOfObject( mwo ) ) then 
        return GeneratorsOfGroupoid( mwo ); 
    fi;
    if not ( HasIsDirectProductWithCompleteDigraph( mwo ) and 
                IsDirectProductWithCompleteDigraph( mwo ) ) then 
        Info( InfoGroupoids, 1, "expecting product with complete graph" ); 
        return fail; 
    fi;
    if ( "IsMonoidWithObjects" in CategoriesOfObject( mwo ) ) then 
        return GeneratorsOfMonoidWithObjects( mwo ); 
    fi; 
    if ( "IsSemigroupWithObjects" in CategoriesOfObject( mwo ) ) then 
        kind := 2; 
        mgens := GeneratorsOfSemigroup( m ); 
    else 
        mgens := GeneratorsOfMagma( m ); 
    fi; 
    gens := ListWithIdenticalEntries( nobs * nobs * Length(mgens), 0 ); 
    k := 0; 
    for i in obs do 
        for j in obs do 
            for g in mgens do
                k := k+1; 
                gens[k] := ArrowNC( mwo, false, g, i, j ); 
            od;
        od;
    od;
    if ( kind = 2 ) then 
        SetGeneratorsOfSemigroupWithObjects( mwo, gens ); 
    fi;
    return gens; 
end );

InstallMethod( GeneratorsOfMagmaWithObjects, "for discrete domain",
    true, [ IsGroupoid and IsSinglePiece and IsDiscreteDomainWithObjects ], 0,
function( mwo ) 

    local o, ogens, gens;  

    gens := [ ];
    for o in mwo!.objects do 
        ogens := GeneratorsOfGroup( ObjectGroup( mwo, o ) ); 
        Add( gens, List( ogens, g -> GroupoidElement( mwo, g, o, o ) ) ); 
    od; 
    return gens; 
end ); 

InstallMethod( GeneratorsOfMagmaWithObjects, "for mwo with >1 piece",
    true, [ IsMagmaWithObjects ], 0,
function( mwo ) 
    return Concatenation( List( Pieces( mwo ), 
               GeneratorsOfMagmaWithObjects ) ); 
end );

InstallMethod( GeneratorsOfSemigroupWithObjects, "for a semigroup with objects", 
    true, [ IsSemigroupWithObjects ], 0, GeneratorsOfMagmaWithObjects );

InstallMethod( GeneratorsOfMonoidWithObjects, "for a monoid with objects", 
    true, [ IsMonoidWithObjects and IsSinglePiece], 0, 
function( mwo )

    local obs, nobs, o1, m, mgens, id, gens1, gens2, gens, i, k;

    obs := mwo!.objects;
    nobs := Length( obs );
    o1 := obs[1];
    m := mwo!.magma; 
    mgens := GeneratorsOfMonoid( m ); 
    id := One( m ); 
    gens1 := List( mgens, g -> ArrowNC( mwo, false, g, o1, o1 ) );
    gens2 := ListWithIdenticalEntries( (nobs-1)^2, 0 ); 
    k := 0;
    for i in [2..nobs] do 
        gens2[k+1] := ArrowNC( mwo, false, id, o1, obs[i] ); 
        gens2[k+2] := ArrowNC( mwo, false, id, obs[i], o1 ); 
        k := k+2; 
    od;
    gens := Immutable( Concatenation( gens1, gens2 ) ); 
    SetGeneratorsOfMonoidWithObjects( mwo, gens ); 
    return gens; 
end );



#############################  MORE THAN ONE PIECE  ######################### 

#############################################################################
##
#M  Pieces . . . . . . . . . . connected components of a domain with objects 
##
InstallMethod( Pieces, "for a single piece domain with objects",
    true, [ IsSinglePieceDomain ], 0,
function( dwo )
    return [ dwo ];
end );

#############################################################################
##
#M  ObjectList . . . . . . . . . . . . . . . . . . . for a magma with objects
##
InstallMethod( ObjectList, "for a magma with objects",
    true, [ IsMagmaWithObjects ], 0,
function( mwo )

    local obs; 

    if ( HasIsSinglePiece( mwo ) and IsSinglePiece( mwo ) ) then
        return mwo!.objects;
    else
        obs := Concatenation( 
            List( Pieces( mwo ), c -> c!.objects ) );
        if not IsDuplicateFree( obs ) then
            Error( "same object in more than one constituent," );
        fi;
        Sort( obs );
        return obs;
    fi;
end );

#############################################################################
##
#M  UnionOfPieces . . . . . . . . for a list of connected magmas with objects
#M  UnionOfPiecesOp 
##
InstallGlobalFunction( UnionOfPieces, 
function( arg )

    local L, npa, part, pieces, p, nco, obs, obp, i, gi, nobj;

    if IsList( arg[1] ) then 
        L := arg[1]; 
    else 
        L := arg; 
    fi; 
    npa := Length( L );
    pieces := [ ]; 
    if ( Length( L ) = 1 ) then 
        return L[1]; 
    fi; 
    for part in L do 
        if not IsDomainWithObjects( part ) then
            Info( InfoGroupoids, 1, "part ", part, "not an mwo" );
            return fail;
        fi;
        if ( HasIsSinglePiece(part) and IsSinglePiece(part) ) then
            Add( pieces, part );
        else
            Append( pieces, Pieces( part ) );
        fi;
    od; 
    obs := [ ]; 
    for p in pieces do 
        obp := ObjectList( p );
        if ( Intersection( obs, obp ) <> [ ] ) then
            Info( InfoGroupoids, 1, 
                  "pieces must have disjoint object sets" );
            return fail;
        fi;
        obs := Union( obs, obp ); 
    od;
    return UnionOfPiecesOp( pieces, pieces[1] );
end );

InstallMethod( UnionOfPiecesOp, "method for magmas with objects",
    true, [ IsList, IsDomainWithObjects ], 0,
function( comps, dom )

    local kind, len, pieces, L, fam, filter, mwo, i, obs, par;

    ## determine which kind:  1=gpd, 2=mon, 3=sgp, 4=mgm, 5=dgpd, 6=dom 
    if ForAll( comps, c -> "IsGroupoid" in CategoriesOfObject( c ) ) then 
        kind := 1; 
    elif ForAll( comps,
                 c -> "IsDoubleGroupoid" in CategoriesOfObject( c ) ) then
        kind := 5;
    elif ForAll( comps, 
                 c -> "IsMonoidWithObjects" in CategoriesOfObject( c ) ) then 
        kind := 2; 
    elif ForAll( comps, 
                 c -> "IsSemigroupWithObjects" in CategoriesOfObject( c ) ) then 
        kind := 3; 
    elif ForAll( comps, 
                 c -> "IsMagmaWithObjects" in CategoriesOfObject( c ) ) then 
        kind := 4;
    else 
        Print( "kind not in {1,2,3,4,5} so TryNextMethod()\n" ); 
        TryNextMethod(); 
    fi;
    Info( InfoGroupoids, 2, "kind = ", kind ); 
    ## order pieces by first object
    len := Length( comps ); 
    obs := List( comps, g -> g!.objects[1] );
    L := [1..len];
    SortParallel( obs, L );
    if ( L = [1..len] ) then 
        pieces := comps; 
    else 
        Info( InfoGroupoids, 2, "reordering pieces by first object" ); 
        pieces := List( L, i -> comps[i] );
    fi;
    if ( kind = 1 ) then 
        fam := IsGroupoidFamily; 
        filter := IsPiecesRep and IsGroupoid and IsAssociative; 
        mwo := Objectify( IsGroupoidPiecesType, rec() );
    elif ( kind = 5 ) then 
        fam := IsDoubleGroupoidFamily; 
        filter := IsPiecesRep and IsDoubleGroupoid and IsAssociative; 
        mwo := Objectify( IsDoubleGroupoidPiecesType, rec() ); 
    elif ( kind = 2 ) then 
        fam := IsMonoidWithObjectsFamily; 
        filter := IsPiecesRep and IsMonoidWithObjects; 
        mwo := Objectify( IsMonoidWOPiecesType, rec() );
    elif ( kind = 3 ) then 
        fam := IsSemigroupWithObjectsFamily; 
        filter := IsPiecesRep and IsSemigroupWithObjects; 
        mwo := Objectify( IsSemigroupWOPiecesType, rec() );
    elif ( kind = 4 ) then 
        fam := IsMagmaWithObjectsFamily; 
        filter := IsPiecesRep and IsMagmaWithObjects; 
        mwo := Objectify( IsMagmaWOPiecesType, rec() ); 
    else 
        ## ?? (23/04/10) fam := FamilyObj( [ pieces ] ); 
        Error( "union of unstructured domains not yet implemented," ); 
    fi; 
    SetIsSinglePieceDomain( mwo, false ); 
    SetIsDirectProductWithCompleteDigraphDomain( mwo, false ); 
    SetPieces( mwo, pieces ); 
    if HasParent( pieces[1] ) then 
        par := Ancestor( pieces[1] ); 
        if ForAll( pieces, c -> ( Ancestor( c ) = par ) ) then 
            SetParent( mwo, par ); 
        fi; 
    fi; 
    if ( kind = 1 ) then 
        if ForAll( pieces, p -> HasIsPermGroupoid(p) and IsPermGroupoid(p) )
             then SetIsPermGroupoid( mwo, true ); 
        elif ForAll( pieces, p -> HasIsPcGroupoid(p) and IsPcGroupoid(p) )
             then SetIsPcGroupoid( mwo, true ); 
        elif ForAll( pieces, p -> HasIsFpGroupoid(p) and IsFpGroupoid(p) )
             then SetIsFpGroupoid( mwo, true ); 
        fi; 
    fi; 
    return mwo; 
end );

#############################################################################
##
#M  MagmaWithSingleObject
##
##  Note that there is another method for [ IsGroup, IsObject ] in gpd.gi 
##
InstallMethod( MagmaWithSingleObject, "generic method for magma, object",
    true, [ IsMagma, IsObject ], 0,
function( mgm, obj ) 

    local o; 

    if ( IsList( obj ) and ( Length(obj) = 1 ) ) then
        Info( InfoGroupoids, 2, "object given as a singleton list" );
        o := obj[1]; 
    else
        o := obj;
    fi; 
    if not IsObject( o ) then 
        Error( "<obj> not a scalar or singleton list," ); 
    fi; 
    if ( HasIsAssociative( mgm ) and IsAssociative( mgm ) 
         and ( "IsMagmaWithInverses" in CategoriesOfObject( mgm ) ) 
         and IsMagmaWithInverses( mgm ) ) then 
        return SinglePieceGroupoidNC( mgm, [o] ); 
    elif ( HasIsMonoid( mgm ) and IsMonoid( mgm ) ) then 
        return SinglePieceMonoidWithObjects( mgm, [o] ); 
    elif ( HasIsSemigroup( mgm ) and IsSemigroup( mgm ) ) then 
        return SinglePieceSemigroupWithObjects( mgm, [o] ); 
    elif ( ( "IsMagma" in CategoriesOfObject(mgm) ) and IsMagma(mgm) ) then 
        return SinglePieceMagmaWithObjects( mgm, [o] ); 
    else 
        Error( "unstructured domains with objects not yet implemented," ); 
    fi; 
end );

############################################################################# 
## 
#M  PieceOfObject
## 
InstallMethod( PieceOfObject, "generic method for magma with objects", 
    true, [ IsDomainWithObjects, IsObject ], 0,
function( dwo, obj )

    local pieces, p, objp;

    if IsSinglePiece( dwo ) then
        if not ( obj in dwo!.objects ) then
            Error( "<obj> not an object of <dwo>," );
        else
            return dwo;
        fi;
    elif not ( obj in ObjectList( dwo ) ) then
        Info( InfoGroupoids, 1, "<obj> not an object of <dwo>" );
        return fail;
    fi;
    pieces := Pieces( dwo );
    for p in pieces do
        objp := p!.objects;
        if ( obj in objp ) then
            return p;
        fi;
    od;
    Info( InfoGroupoids, 1, "it appears that <obj> is not an object in <dwo>" );
    return fail;
end );

############################################################################# 
## 
#M  PieceNrOfObject
## 
InstallMethod( PieceNrOfObject, "generic method for domain with objects",
    true, [ IsDomainWithObjects, IsObject ], 0,
function( dwo, obj )

    local pieces, i, objp, np; 

    pieces := Pieces( dwo );
    for i in [1..Length( pieces )] do
        objp := pieces[i]!.objects;
        if ( obj in objp ) then
            return i;
        fi;
    od;
    Info( InfoGroupoids, 1, "it appears that <obj> is not an object in <dwo>" );
    return fail;
end );

#############################################################################
##
#M  IsDiscreteDomainWithObjects 
##
InstallMethod( IsDiscreteDomainWithObjects, "for a magma with objects", true,
    [ IsDomainWithObjects ], 0,
function( dwo )

    local p; 

    for p in Pieces( dwo ) do
        if not ( Length( p!.objects ) = 1 ) then
            return false;
        fi;
    od;
    return true;
end );

#############################################################################
##
#M  IsHomogeneousDomainWithObjects 
##
InstallMethod( IsHomogeneousDomainWithObjects, "for a magma with objects", 
    true, [ IsDiscreteDomainWithObjects ], 0,
function( dwo )

    local pieces, g, j, iso; 

    pieces := Pieces( dwo ); 
    g := pieces[1]!.magma; 
    return ForAll( [2..Length(pieces)], j -> ( g = pieces[j]!.magma ) ); 
end );

InstallMethod( IsHomogeneousDomainWithObjects, "for a magma with objects", 
    true, [ IsDomainWithObjects ], 0,
function( dwo )

    local pieces, sizes, g, j, iso; 

    pieces := Pieces( dwo ); 
    sizes := Set( List( pieces, Size ) ); 
    if not ( Length( sizes ) = 1 ) then 
        return false; 
    fi;
    g := pieces[1]!.magma; 
    return ForAll( [2..Length(pieces)], j -> ( g = pieces[j]!.magma ) ); 
end );


#################################  SUBDOMAINS  ############################## 

#############################################################################
##
#F  IsSubdomainWithObjects( <M>, <U> )
##
InstallMethod( IsSubdomainWithObjects, "for two domains with objects", true, 
    [ IsDomainWithObjects, IsDomainWithObjects ], 0, 
function( D, U )

    local compU, obj, genU, p, ok; 

    ##  insisting that a subdomain of a groupoid is a groupoid 
    ok := false; 
    if not ( IsMagmaWithObjects(D) and IsMagmaWithObjects(U) ) then
        Error( "not yet implemented for unstructured domains," ); 
    fi;
    if ( HasParentAttr(U) and ( ParentAttr(U) = D ) ) then 
        return true;
    fi;
    if not IsSubset( ObjectList(D), ObjectList(U) ) then
        return false;
    fi; 
    if ( IsSinglePiece(D) and IsSinglePiece(U) ) then
        obj := U!.objects[1];
        if ( IsGroupoid(D) and IsGroupoid(U) ) then 
            genU := GeneratorsOfGroupoid(U); 
            ok := ForAll( genU, g -> g in D ); 
##      elif ( IsMonoid(D) and IsMonoid(U) ) then 
##          ok := ( IsSubsemigroup( D!.magma, U!.magma ) 
##                  and IsMonoid( D!.magma ) ); 
##      elif ( IsSemigroup(D) and IsSemigroup(U) ) then 
##          ok := IsSubsemigroup( D!.magma, U!.magma ); 
        else 
            ok := IsSubset( GeneratorsOfMagma( D!.magma ), 
                            GeneratorsOfMagma( U!.magma ) ); 
        fi;
    elif IsSinglePiece(U) then
        obj := U!.objects[1];
        p := PieceOfObject( D, obj ); 
        ok := IsSubdomainWithObjects( p, U );
    else
        compU := Pieces(U);
        ok := ForAll( compU, p -> IsSubdomainWithObjects( D, p ) );
    fi;
    if ( ok and not HasParentAttr( U ) ) then 
        SetParent( U, D ); 
    fi; 
    return ok; 
end );

#############################################################################
##
#F  SubdomainWithObjects( <M>, <U> )
##
InstallGlobalFunction( SubdomainWithObjects, function( arg ) 

    local nargs, dwo, isgpd; 

    nargs := Length( arg ); 
    dwo := arg[1]; 
    isgpd := ( "IsGroupoid" in CategoriesOfObject( dwo ) ); 
    if isgpd then 
        if ( nargs = 2 ) then 
            return Subgroupoid( arg[1], arg[2] ); 
        elif ( nargs = 3 ) then 
            return Subgroupoid( arg[1], arg[2], arg[3] ); 
        elif ( nargs = 4 ) then 
            return Subgroupoid( arg[1], arg[2], arg[3], arg[4] ); 
        else 
            Error( "expecting 2, 3 or 4 arguments" ); 
        fi;
    else 
        Error( "SubdomainWithObjects needs more implementation" ); 
    fi; 
end );


################################  SEMIGROUPS  ############################### 

############################################################################# 
## 
#F  SemigroupWithObjects( <sgp>, <obs> ) 
##
InstallGlobalFunction( SemigroupWithObjects, function( arg ) 

    local obs, sgp; 

    # list of objects and a semigroup 
    if ( (Length(arg) = 2) and IsSemigroup( arg[1] ) and IsSet( arg[2] ) ) then 
        sgp := arg[1]; 
        obs := arg[2]; 
        if HasGeneratorsOfMagmaWithInverses( sgp ) then  
            return SinglePieceGroupoid( sgp, obs ); 
        elif ( HasIsMonoid( sgp ) and IsMonoid( sgp ) ) then 
            return SinglePieceMonoidWithObjects( sgp, obs ); 
        else  ## it's just a semigroup
            return SinglePieceSemigroupWithObjects( sgp, obs ); 
        fi; 
    else 
        Error( "Current usage: SemigroupWithObjects( <sgp>, <obs> )," ); 
    fi; 
end ); 

############################################################################# 
## 
#M  SinglePieceSemigroupWithObjects( <sgp>, <obs> ) . for semigroup, objects
##
InstallMethod( SinglePieceSemigroupWithObjects, 
    "for objects, semigroup", true, [ IsSemigroup, IsCollection ], 0, 
function( sgp, obs ) 

    local gens, swo; 

    swo := rec( objects := obs, magma := sgp ); 
    ObjectifyWithAttributes( swo, IsSemigroupWithObjectsType, 
        IsAssociative, IsAssociative( sgp ), 
        IsCommutative, IsCommutative( sgp ), 
        IsFinite, IsFinite( sgp ), 
        IsSinglePieceDomain, true, 
        IsDirectProductWithCompleteDigraphDomain, true ); 
    gens := GeneratorsOfSemigroupWithObjects( swo ); 
    return swo; 
end ); 


##################################  MONOIDS  ################################ 

############################################################################# 
## 
#F  MonoidWithObjects( <mon>, <obs> ) 
##
InstallGlobalFunction( MonoidWithObjects, function( arg ) 

    local obs, mon; 

    # list of objects and a monoid 
    if ( ( Length(arg) = 2 ) and IsMonoid( arg[1] )  and IsSet( arg[2] ) ) then 
        mon := arg[1]; 
        obs := arg[2]; 
        if HasGeneratorsOfMagmaWithInverses( mon ) then  
            return SinglePieceGroupoid( mon, obs ); 
        else  ## it's just a monoid
            return SinglePieceMonoidWithObjects( mon, obs ); 
        fi; 
    else 
        Error( "Current usage: MonoidWithObjects( <mon>, <obs> )," ); 
    fi; 
end ); 

############################################################################# 
## 
#M  SinglePieceMonoidWithObjects( <mon>, <sgp> ) . . . for semigroup, objects 
##
InstallMethod( SinglePieceMonoidWithObjects, 
    "for objects, monoid", true, [ IsMonoid, IsCollection ], 0, 
function( mon, obs ) 

    local gens, mwo; 

    mwo := rec( objects := obs, magma := mon ); 
    ObjectifyWithAttributes( mwo, IsMonoidWithObjectsType, 
        IsAssociative, IsAssociative( mon ), 
        IsCommutative, IsCommutative( mon ), 
        IsSinglePieceDomain, true, 
        IsDirectProductWithCompleteDigraphDomain, true, 
        IsFinite, HasIsFinite( mon ) and IsFinite( mon ) );
    gens := GeneratorsOfMonoidWithObjects( mwo ); 
    return mwo; 
end ); 


##################################  GROUPS  ################################# 
##  A *group with objects* is a magma with objects where the vertex magmas 
##  are groups, and so is a *groupoid* - see file gpd.gi.


#################################  SUBMAGMAS  ############################### 

############################################################################# 
## 
#M  IsSubmagmaWithObjectsGeneratingTable( <mag>, <A> ) 
##
InstallMethod( IsSubmagmaWithObjectsGeneratingTable, "for magma and array", 
    true, [ IsMagma, IsList ], 0, 
function( mag, A ) 

    local n, s, a, b, e;

    n := Length( A );    ## number of objects 
    s := Size( mag );  
    e := [1..s]; 
    for a in A do 
        if not ( IsList(a) and ( Length(a) = n ) ) then 
            return false; 
        fi; 
        for b in a do 
            if not IsSubset( e, b ) then 
                return false; 
            fi; 
        od; 
    od; 
    return true; 
end ); 

############################################################################# 
## 
#M  SubmagmaWithObjectsElementsTable( <mag>, <A> ) 
##
InstallMethod( SubmagmaWithObjectsElementsTable, "for magma and array", 
    true, [ IsMagma, IsList ], 0, 
function( mag, A ) 

    local t, done, B, C, T, n, s, i, j, k, Lij, Lik, Ljk, a, b, ab; 

    if not IsSubmagmaWithObjectsGeneratingTable( mag, A ) then 
        Error( "array A is not a generating table for a submagma over mag," ); 
    fi; 
    T := MultiplicationTable( mag ); 
    s := Size( mag ); 
    n := Length( A ); 
    done := false; 
    C := StructuralCopy( A ); 
    t := 0; 
    while not done do 
        t := t+1; 
        B := StructuralCopy( C );   ## C stores all the elements 
        for i in [1..n] do 
            for j in [1..n] do 
                Lij := C[i][j]; 
                for k in [1..n] do 
                    Ljk := C[j][k]; 
                    for a in Lij do 
                        for b in Ljk do 
                            ab := T[a][b]; 
                            C[i][k] := Union( C[i][k], [ab] ); 
                        od; 
                    od; 
                od; 
            od; 
        od; 
        done := ( B = C ); 
    od;
    return C;        
end ); 

############################################################################# 
## 
#M  SubmagmaWithObjectsByElementsTable( <mwo>, <A> ) . . for mwo and elements 
##
InstallMethod( SubmagmaWithObjectsByElementsTable, 
    "for objects, magma and table of generating elements", true, 
    [ IsSinglePiece, IsList ], 0, 
function( mwo, A ) 

    local C, mag, obs, cf, isa, isc, swo; 

    obs := mwo!.objects; 
    mag := mwo!.magma; 
    C := SubmagmaWithObjectsElementsTable( mag, A ); 
    ## ?? (23/04/10)  cf := mwo!.eltsfam; 
    cf := IsMagmaWithObjectsFamily; 
    isa := IsAssociative( mag ); 
    isc := IsCommutative( mag ); 
    swo := rec( objects := obs, magma := mag, table := C ); 
    ObjectifyWithAttributes( swo, 
        NewType( cf, IsSubmagmaWithObjectsTableRep ), 
        ParentAttr, mwo,
        IsAssociative, IsAssociative( mag ), 
        IsCommutative, IsCommutative( mag ), 
        IsFinite, IsFinite( mag ), 
        IsSinglePieceDomain, true ); 
    #? (13/10/08)  still need to set GeneratorsOfMagmaWithObjects ?? 
    return swo; 
end ); 

############################################################################# 
## 
#M  PrintObj( <swo> ) . . . . .  for submagma with objects and elements table
##

InstallMethod( PrintObj, "for a submagma with objects and elements table", 
    true, [ IsSubmagmaWithObjectsTableRep ], 0, 
function( M ) 
    Print( "submagma with objects:-\n" ); 
    Print( "objects = ", M!.objects, "\n" );
    Print( "  magma = ", M!.magma, "\n" );  
    Print( "  table = ", M!.table, "\n" ); 
end );


#################################  UTILITIES  ############################### 

############################################################################# 
## 
#M  Ancestor 
## 
InstallMethod( Ancestor, "method for a domain with objects", 
    true, [ IsDomainWithObjects ], 0,
function( dom ) 

    local found, d; 

    d := dom; 
    found := ( HasParent( d ) and ( Parent( d ) = d ) ); 
    while not found do 
        if not HasParent( d ) then 
            return fail; 
        else
            d := Parent( d ); 
            found := ( Parent( d ) = d ); 
        fi; 
    od; 
    return d; 
end );


#############################################################################
##
#M  Iterator( <mwo> ) . . . .  iterator for a single piece magma with objects
##
InstallMethod( Iterator, "for a single piece magma with objects", 
    [ IsSinglePiece ], 
function( mwo )
    return IteratorByFunctions( rec( 
        IsDoneIterator := function( iter )
            return ( IsDoneIterator( iter!.magmaIterator ) 
                     and ( iter!.tpos = iter!.len )
                     and ( iter!.hpos = iter!.len ) );
            end, 
        NextIterator := function( iter )
            if ( iter!.tpos = 0 ) then
                iter!.melt := NextIterator( iter!.magmaIterator );
                iter!.tpos := 1;
                iter!.hpos := 1;
            elif ((iter!.tpos = iter!.len) and (iter!.hpos = iter!.len)) then 
                iter!.melt := NextIterator( iter!.magmaIterator );
                iter!.tpos := 1;
                iter!.hpos := 1;
            elif ( iter!.hpos = iter!.len ) then
                iter!.hpos := 1;
                iter!.tpos := iter!.tpos + 1;
            else 
                iter!.hpos := iter!.hpos + 1;
            fi;
            if ( HasIsDirectProductWithCompleteDigraph( mwo ) 
                 and IsDirectProductWithCompleteDigraph( mwo ) ) then 
               return Arrow( mwo, iter!.melt, 
                   iter!.obs[iter!.tpos], iter!.obs[iter!.hpos] );
            else 
               return fail;
            fi; 
            end, 
        ShallowCopy := iter -> 
            rec( magmaIterator := ShallowCopy( iter!.magmaIterator ), 
                 melt := iter!.melt,
                 obs := iter!.obs,
                 len := iter!.len,
                 tpos := iter!.tpos,
                 hpos := iter!.hpos ),
        magmaIterator := Iterator( mwo!.magma ), 
        melt := 0, 
        obs := mwo!.objects,
        len := Length( mwo!.objects ),
        tpos := 0,
        hpos := 0 ) );
end );

InstallMethod( Iterator, "generic method for a magma with objects", 
    [ IsMagmaWithObjects ], 
function( mwo )
    return IteratorByFunctions( rec( 
        IsDoneIterator := function( iter )
            return ( IsDoneIterator( iter!.mwoIterator ) 
                     and ( iter!.cpos = iter!.len ) );
            end, 
        NextIterator := function( iter )
            if IsDoneIterator( iter!.mwoIterator ) then 
                iter!.cpos := iter!.cpos + 1;
                iter!.mwoIterator := 
                    Iterator( iter!.pieces[iter!.cpos] );
            fi;
            return NextIterator( iter!.mwoIterator );
            end,
        ShallowCopy := iter -> 
            rec( pieces := iter!.pieces,
                 len := iter!.len,
                 mwoIterator := ShallowCopy( iter!.mwoIterator ),
                 cpos := iter!.cpos ),
        pieces := Pieces( mwo ),
        len := Length( Pieces( mwo ) ),
        mwoIterator := Iterator( Pieces( mwo )[1] ),
        cpos := 1 ) );
end );

#############################################################################
##
#E  mwo.gi  . . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here
##