Quelle fixedrep.gi Sprache: unbekannt

#############################################################################
##
#W fixedrep.gi GAP4 Package `ResClasses' Stefan Kohl
##
## This file contains implementations of methods and functions for
## computing with unions of residue classes with distinguished ("fixed")
## representatives.
##
#############################################################################

#############################################################################
##
#S Implications between the categories. ////////////////////////////////////
##
#############################################################################

InstallTrueMethod( IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesOfZorZ_piWithFixedRepresentatives);
InstallTrueMethod( IsUnionOfResidueClassesOfZorZ_piWithFixedRepresentatives,
 IsUnionOfResidueClassesOfZWithFixedRepresentatives );
InstallTrueMethod( IsUnionOfResidueClassesOfZorZ_piWithFixedRepresentatives,
 IsUnionOfResidueClassesOfZ_piWithFixedRepresentatives );
InstallTrueMethod( IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesOfGFqxWithFixedRepresentatives );

#############################################################################
##
#S Residue classes (mod m). ////////////////////////////////////////////////
##
#############################################################################

#############################################################################
##
#F AllResidueClassesWithFixedRepresentativesModulo( [ <R>, ] <m> )
#F AllResidueClassesWithFixedRepsModulo( [ <R>, ] <m> )
##
InstallGlobalFunction( AllResidueClassesWithFixedRepresentativesModulo,

 function ( arg )

 local R, m;

 if Length(arg) = 2
 then R := arg[1]; m := arg[2];
 else m := arg[1]; R := DefaultRing(m); fi;
 if IsZero(m) or not m in R then return fail; fi;
 return List(AllResidues(R,m),r->ResidueClassWithFixedRep(R,m,r));
 end );

#############################################################################
##
#S Construction of unions of residue classes with fixed representatives. ///
##
#############################################################################

#############################################################################
##
#M UnionOfResidueClassesWithFixedRepresentativesCons(<filter>,<R>,<classes>)
##
InstallMethod( UnionOfResidueClassesWithFixedRepresentativesCons,
 "for Z, Z_pi and GF(q)[x] (ResClasses)", ReturnTrue,
 [ IsUnionOfResidueClassesWithFixedRepresentatives,
 IsRing, IsList ], 0,

 function ( filter, R, classes )

 local Result, fam, type, rep;

 if not ( IsIntegers( R ) or IsZ_pi( R )
 or ( IsFiniteFieldPolynomialRing( R )
 and IsUnivariatePolynomialRing( R ) ) )
 then TryNextMethod( ); fi;
 fam := ResidueClassUnionsFamily( R, true );
 if IsIntegers( R )
 then type := IsUnionOfResidueClassesOfZWithFixedRepresentatives;
 elif IsZ_pi( R )
 then type := IsUnionOfResidueClassesOfZ_piWithFixedRepresentatives;
 elif IsPolynomialRing( R )
 then type := IsUnionOfResidueClassesOfGFqxWithFixedRepresentatives; fi;
 rep := IsUnionOfResidueClassesWithFixedRepsStandardRep;
 Result := Objectify( NewType( fam, type and rep ),
 rec( classes := AsSortedList( classes ) ) );
 if classes <> [] then
 SetSize( Result, infinity ); SetIsFinite( Result, false );
 SetIsEmpty( Result, false );
 SetRepresentative( Result, classes[1][2] );
 else
 SetSize( Result, 0 ); SetIsEmpty( Result, true );
 fi;
 return Result;
 end );

#############################################################################
##
#F UnionOfResidueClassesWithFixedRepresentatives( <R>, <classes> )
#F UnionOfResidueClassesWithFixedRepresentatives( <classes> )
#F UnionOfResidueClassesWithFixedReps( <R>, <classes> )
#F UnionOfResidueClassesWithFixedReps( <classes> )
##
InstallGlobalFunction( UnionOfResidueClassesWithFixedRepresentatives,

 function ( arg )

 local R, classes, usage;

 usage := Concatenation("usage: UnionOfResidueClassesWithFixedRepresenta",
 "tives( [ <R>, ] <classes> )\n");
 if not Length(arg) in [1,2] then Error(usage); return fail; fi;
 if Length(arg) = 2 then R := arg[1]; classes := arg[2];
 else R := Integers; classes := arg[1]; fi;
 if not IsIntegers(R) and not IsZ_pi(R) and not IsPolynomialRing(R)
 or not IsList(classes) or not ForAll(classes,IsList)
 or not ForAll(classes,cl->Length(cl)=2)
 or not IsSubset(R,Flat(classes))
 or IsZero(Product(List(classes,cl->cl[1])))
 then Error(usage); return fail; fi;
 return UnionOfResidueClassesWithFixedRepresentativesCons(
 IsUnionOfResidueClassesWithFixedRepresentatives, R, classes );
 end );

#############################################################################
##
#F ResidueClassWithFixedRepresentative( <R>, <m>, <r> )
#F ResidueClassWithFixedRepresentative( <m>, <r> )
#F ResidueClassWithFixedRep( <R>, <m>, <r> )
#F ResidueClassWithFixedRep( <m>, <r> )
##
InstallGlobalFunction( ResidueClassWithFixedRepresentative,

 function ( arg )

 local R, m, r, cl, usage;

 usage := Concatenation("usage: ResidueClassWithFixedRepresentative",
 "( [ <R>, ] <m>, <r> ) for a ring <R> and ",
 "elements <m> and <r>.\n");
 if not Length(arg) in [2,3] then Error(usage); return fail; fi;
 if Length(arg) = 3 then R := arg[1]; m := arg[2]; r := arg[3];
 else R := Integers; m := arg[1]; r := arg[2]; fi;
 if not ( IsRing(R) and m in R and r in R )
 then Error(usage); return fail; fi;
 cl := UnionOfResidueClassesWithFixedRepresentatives( R, [ [ m, r ] ] );
 SetIsResidueClassWithFixedRepresentative( cl, true );
 return cl;
 end );

#############################################################################
##
#M IsResidueClassWithFixedRepresentative( <obj> ) . . . . . general method
##
InstallMethod( IsResidueClassWithFixedRepresentative,
 "general method (ResClasses)", true, [ IsObject ], 0,

 function ( obj )
 if IsUnionOfResidueClassesWithFixedRepresentatives(obj)
 and Length(Classes(obj)) = 1
 then return true; fi;
 return false;
 end );

#############################################################################
##
#M Modulus( <cl> ) . . . . . . for residue classes with fixed representative
##
InstallMethod( Modulus,
 "for residue classes with fixed representative (ResClasses)",
 true, [ IsResidueClassWithFixedRepresentative ], SUM_FLAGS,
 cl -> Classes(cl)[1][1] );

#############################################################################
##
#M Residue( <cl> ) . . . . . . for residue classes with fixed representative
##
InstallMethod( Residue,
 "for residue classes with fixed representative (ResClasses)",
 true, [ IsResidueClassWithFixedRepresentative ], 0,
 cl -> Classes(cl)[1][2] );

#############################################################################
##
#M AsOrdinaryUnionOfResidueClasses( )
##
InstallMethod( AsOrdinaryUnionOfResidueClasses,
 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U )

 local R, cl;

 R := UnderlyingRing(FamilyObj(U));
 return Union(List(Classes(U),cl->ResidueClass(R,cl[1],cl[2])));
 end );

#############################################################################
##
#S Accessing the components of a union of residue classes object. //////////
##
#############################################################################

#############################################################################
##
#M Modulus( ) . . . . . . for unions of residue classes with fixed rep's
##
InstallMethod( Modulus,
 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,
 U -> Lcm( UnderlyingRing( FamilyObj( U ) ),
 List( U!.classes, cl -> cl[1] ) ) );

#############################################################################
##
#M Classes( ) . . . . . . for unions of residue classes with fixed rep's
##
InstallMethod( Classes,
 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,
 U -> U!.classes );

#############################################################################
##
#S Testing for equality. ///////////////////////////////////////////////////
##
#############################################################################

#############################################################################
##
#M \=( <U1>, <U2> ) . . . . . for unions of residue classes with fixed rep's
##
InstallMethod( \=,

 "for two unions of residue classes with fixed rep's (ResClasses)",
 IsIdenticalObj,
 [ IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U1, U2 )
 return U1!.classes = U2!.classes;
 end );

#############################################################################
##
#M \<( <U1>, <U2> ) . . . . . for unions of residue classes with fixed rep's
##
## A total ordering of unions of residue classes with fixed representatives
## (for technical purposes, only).
##
InstallMethod( \<,

 "for two unions of residue classes with fixed rep's (ResClasses)",
 IsIdenticalObj,
 [ IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U1, U2 ) return U1!.classes < U2!.classes; end );

#############################################################################
##
#S Membership and multiplicity. ////////////////////////////////////////////
##
#############################################################################

#############################################################################
##
#M \in( <n>, ) . for ring element and union of res.-cl. with fixed rep's
##
InstallMethod( \in,

 "for a ring element and a union of res.-cl. with fixed rep's (ResClasses)",
 ReturnTrue,
 [ IsRingElement, IsUnionOfResidueClassesWithFixedRepresentatives ],
 SUM_FLAGS,

 function ( n, U ) return Multiplicity(n,U) >= 1; end );

#############################################################################
##
#M \in( <cl>, ) . . . for res.-cl and union of res.-cl. with fixed rep's
##
InstallMethod( \in,

 "for a res.-cl. and a union of res.-cl. with fixed rep's (ResClasses)",
 ReturnTrue,
 [ IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( cl, U )
 if Length(cl!.classes) > 1 then TryNextMethod(); fi;
 return cl!.classes[1] in U!.classes;
 end );

#############################################################################
##
#M Multiplicity( <n>, )
##
InstallMethod( Multiplicity,

 "for a ring element and a union of res.-cl. with fixed rep's (ResClasses)",
 ReturnTrue,
 [ IsRingElement, IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( n, U )
 if not n in UnderlyingRing(FamilyObj(U)) then return 0; fi;
 return Number(U!.classes,cl->n mod cl[1] = cl[2]);
 end );

#############################################################################
##
#M Multiplicity( <cl>, )
##
InstallMethod( Multiplicity,

 "for a res.-cl. and union of res.-cl. with fixed rep's (ResClasses)",
 ReturnTrue,
 [ IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( cl, U )
 return Number( AsListOfClasses( U ), unioncl -> unioncl = cl );
 end );

#############################################################################
##
#S Density and subset relations. ///////////////////////////////////////////
##
#############################################################################

#############################################################################
##
#M Density( ) . . . . . . for unions of residue classes with fixed rep's
##
InstallOtherMethod( Density,

 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U )

 local R;

 R := UnderlyingRing(FamilyObj(U));
 return Sum(List(U!.classes,c->1/Length(AllResidues(R,c[1]))));
 end );

#############################################################################
##
#M IsOverlappingFree( ) . for unions of residue classes with fixed rep's
##
InstallMethod( IsOverlappingFree,

 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 U -> Density( U ) = Density( AsOrdinaryUnionOfResidueClasses( U ) ) );

#############################################################################
##
#M IsSubset( <U1>, <U2> ) . . for unions of residue classes with fixed rep's
##
InstallMethod( IsSubset,

 "for two unions of residue classes with fixed rep's (ResClasses)",
 IsIdenticalObj,
 [ IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U1, U2 )

 local R, cls, classes, numbers;

 R := UnderlyingRing(FamilyObj(U1));
 cls := [Classes(U1),Classes(U2)];
 classes := Set(Union(cls));
 numbers := List(classes,cl1->List(cls,list->Number(list,cl2->cl2=cl1)));
 return ForAll(numbers,num->num[1]>=num[2]);
 end );

#############################################################################
##
#S Computing unions, intersections and differences. ////////////////////////
##
#############################################################################

#############################################################################
##
#M Union2( <U1>, <U2> ) . . . for unions of residue classes with fixed rep's
##
InstallMethod( Union2,

 "for two unions of residue classes with fixed rep's (ResClasses)",
 IsIdenticalObj,
 [ IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U1, U2 )
 return UnionOfResidueClassesWithFixedRepresentatives(
 UnderlyingRing(FamilyObj(U1)),
 Concatenation(Classes(U1),Classes(U2)));
 end );

#############################################################################
##
#M Intersection2( <U1>, <U2> ) . for unions of res.-classes with fixed rep's
##
InstallMethod( Intersection2,

 "for two unions of residue classes with fixed rep's (ResClasses)",
 IsIdenticalObj,
 [ IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U1, U2 )

 local R, cls, cls1, cls2, int, cl;

 R := UnderlyingRing(FamilyObj(U1));
 cls1 := Classes(U1); cls2 := Classes(U2); int := Intersection(cls1,cls2);
 cls := Concatenation(List(int,cl->ListWithIdenticalEntries(
 Minimum(Number(cls1,cl1->cl1=cl),Number(cls2,cl2->cl2=cl)),cl)));
 return UnionOfResidueClassesWithFixedRepresentatives( R, cls );
 end );

#############################################################################
##
#M Difference( <U1>, <U2> ) . for unions of residue classes with fixed rep's
##
InstallMethod( Difference,

 "for two unions of residue classes with fixed rep's (ResClasses)",
 IsIdenticalObj,
 [ IsUnionOfResidueClassesWithFixedRepresentatives,
 IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U1, U2 )

 local Multiple, R, cls, classes, numbers, diffcls;

 Multiple := function ( cl, k )
 if k < 0
 then return ListWithIdenticalEntries(-k,[cl[1],cl[1]-cl[2]]);
 else return ListWithIdenticalEntries(k,cl); fi;
 end;

 R := UnderlyingRing(FamilyObj(U1));
 cls := [Classes(U1),Classes(U2)];
 classes := Set(Union(cls));
 numbers := List(classes,cl1->List(cls,list->Number(list,cl2->cl2=cl1)));
 numbers := TransposedMat(numbers); numbers := numbers[1] - numbers[2];
 diffcls := Concatenation(List([1..Length(numbers)],
 i->Multiple(classes[i],numbers[i])));
 return UnionOfResidueClassesWithFixedRepresentatives( R, diffcls );
 end );

#############################################################################
##
#S Applying arithmetic operations to the residue classes. //////////////////
##
#############################################################################

#############################################################################
##
#M \+( , <x> ) . for union of res.-cl. with fixed rep's and ring element
##
InstallOtherMethod( \+,

 "for a union of res.-cl. with fixed rep's and a ring element (ResClasses)",
 ReturnTrue,
 [ IsUnionOfResidueClassesWithFixedRepresentatives, IsRingElement ], 0,

 function ( U, x )
 return UnionOfResidueClassesWithFixedRepresentatives(
 UnderlyingRing(FamilyObj(U)),
 List(Classes(U),cl->[cl[1],cl[2]+x]) );
 end );

#############################################################################
##
#M \+( <x>, ) . for ring element and union of res.-cl. with fixed rep's
##
InstallOtherMethod( \+,

 "for a ring element and a union of res.-cl. with fixed rep's (ResClasses)",
 ReturnTrue,
 [ IsRingElement, IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( x, U ) return U + x; end );

#############################################################################
##
#M AdditiveInverseOp( ) . for unions of residue classes with fixed rep's
##
InstallOtherMethod( AdditiveInverseOp,

 "for unions of residue classes with fixed rep's (ResClasses)",
 ReturnTrue, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U )

 local R, invclasses;

 R := UnderlyingRing(FamilyObj(U));
 invclasses := List(Classes(U),cl->[-cl[1],-cl[2]]);
 return UnionOfResidueClassesWithFixedRepresentatives(R,invclasses);
 end );

#############################################################################
##
#M \-( , <x> ) . for union of res.-cl. with fixed rep's and ring element
##
InstallOtherMethod( \-,

 "for a union of res.-cl. with fixed rep's and a ring element (ResClasses)",
 ReturnTrue,
 [ IsUnionOfResidueClassesWithFixedRepresentatives, IsRingElement ], 0,

 function ( U, x ) return U + (-x); end );

#############################################################################
##
#M \-( <x>, ) . for ring element and union of res.-cl. with fixed rep's
##
InstallOtherMethod( \-,

 "for a ring element and a union of res.-cl. with fixed rep's (ResClasses)",
 ReturnTrue,
 [ IsRingElement, IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( x, U ) return (-U) + x; end );

#############################################################################
##
#M \*( , <x> ) . for union of res.-cl. with fixed rep's and ring element
##
InstallOtherMethod( \*,

 "for a union of res.-cl. with fixed rep's and a ring element (ResClasses)",
 ReturnTrue,
 [ IsUnionOfResidueClassesWithFixedRepresentatives, IsRingElement ], 0,

 function ( U, x )

 local R;

 R := UnderlyingRing(FamilyObj(U));
 return UnionOfResidueClassesWithFixedRepresentatives( R, Classes(U)*x );
 end );

#############################################################################
##
#M \*( <x>, ) . for ring element and union of res.-cl. with fixed rep's
##
InstallOtherMethod( \*,

 "for a ring element and a union of res.-cl. with fixed rep's (ResClasses)",
 ReturnTrue,
 [ IsRingElement, IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( x, U ) return U * x; end );

#############################################################################
##
#M \/( , <x> ) . for union of res.-cl. with fixed rep's and ring element
##
InstallOtherMethod( \/,

 "for a union of res.-cl. with fixed rep's and a ring element (ResClasses)",
 ReturnTrue,
 [ IsUnionOfResidueClassesWithFixedRepresentatives, IsRingElement ], 0,

 function ( U, x )

 local R, quotclasses;

 R := UnderlyingRing(FamilyObj(U));
 quotclasses := Classes(U)/x;
 if not IsSubset(R,Flat(quotclasses)) then TryNextMethod(); fi;
 return UnionOfResidueClassesWithFixedRepresentatives( R, quotclasses );
 end );

#############################################################################
##
#S Computing partitions into residue classes. //////////////////////////////
##
#############################################################################

#############################################################################
##
#M AsListOfClasses( ) . . for unions of residue classes with fixed rep's
##
InstallMethod( AsListOfClasses,
 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 U -> SortedList( List( Classes( U ),
 cl -> ResidueClassWithFixedRepresentative(
 UnderlyingRing( FamilyObj( U ) ), cl[1], cl[2] ) ) ) );

#############################################################################
##
#S The invariants Delta and Rho. ///////////////////////////////////////////
##
#############################################################################

#############################################################################
##
#M Delta( ) . . . . for unions of residue classes of Z with fixed rep's
##
InstallMethod( Delta,

 "for unions of residue classes of Z with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesOfZWithFixedRepresentatives ], 0,

 U -> Sum(List(Classes(U),c->c[2]/c[1])) - Length(Classes(U))/2 );

#############################################################################
##
#M Rho( ) . . . . . for unions of residue classes of Z with fixed rep's
##
InstallMethod( Rho,

 "for unions of residue classes of Z with fixed rep's (ResClasses)", true,
 [ IsUnionOfResidueClassesOfZWithFixedRepresentatives ], 0,

 function ( U )

 local product, factor, classes, cl, delta;

 product := 1;
 classes := AsListOfClasses(U);
 for cl in classes do
 delta := Delta(cl)/2;
 factor := E(DenominatorRat(delta))^NumeratorRat(delta);
 if Classes(cl)[1][1] < 0 then factor := factor^-1; fi;
 product := product * factor;
 od;
 return product;
 end );

#############################################################################
##
#M RepresentativeStabilizingRefinement( , <k> )
##
InstallMethod( RepresentativeStabilizingRefinement,

 Concatenation("for a union of residue classes of Z with fixed rep's and ",
 "a positive integer (ResClasses)"), ReturnTrue,
 [ IsUnionOfResidueClassesOfZWithFixedRepresentatives, IsPosInt ], 0,

 function ( U, k )

 local classes;

 classes := Concatenation(List(Classes(U),
 cl->List([0..k-1],
 i->[k*cl[1],i*cl[1]+cl[2]])));
 return UnionOfResidueClassesWithFixedRepresentatives(Integers,classes);
 end );

#############################################################################
##
#M RepresentativeStabilizingRefinement( , 0 )
##
InstallMethod( RepresentativeStabilizingRefinement,

 Concatenation("for a union of residue classes of Z with fixed rep's and 0",
 " (simplify) (ResClasses)"),
 ReturnTrue, [ IsUnionOfResidueClassesOfZWithFixedRepresentatives,
 IsInt and IsZero ], 0,

 function ( U, k )

 local cls, olds, mods, parts, part, mp, rp, kp, m, complete, c,
 progression, replacement, found, cl, pos;

 cls := ShallowCopy(Classes(U));
 if Length(cls) < 2 then return U; fi;
 repeat
 olds := ShallowCopy(cls);
 mods := Set(List(cls,cl->cl[1]));
 parts := List(mods,m->Filtered(cls,cl->cl[1]=m));
 found := false;
 for part in parts do
 mp := part[1][1]; rp := Set(part,cl->cl[2]);
 for kp in Intersection([2..Length(rp)],DivisorsInt(mp)) do
 m := mp/kp;
 complete := First(Collected(rp mod m),c->c[2]=kp);
 if complete <> fail then
 progression := Set(Filtered(part,t->t[2] mod m = complete[1]));
 if Set(List([1..Length(progression)-1],
 i->progression[i+1][2]-progression[i][2]))
 <> [AbsInt(m)]
 then continue; fi;
 if m < 0 then progression := Reversed(progression); fi;
 replacement := [[m,progression[1][2]]];
 while progression <> [] do
 cl := progression[1];
 pos := Position(cls,cl);
 Unbind(cls[pos]);
 cls := SortedList(cls);
 Unbind(progression[1]);
 progression := SortedList(progression);
 od;
 cls := Concatenation(cls,replacement);
 found := true;
 fi;
 if found then break; fi;
 od;
 if found then break; fi;
 od;
 until cls = olds;
 return UnionOfResidueClassesWithFixedRepresentatives(Integers,cls);
 end );

#############################################################################
##
#S Viewing, printing and displaying unions of residue classes. /////////////
##
#############################################################################

#############################################################################
##
#M ViewString( <cl> ) . . . . . . . . . for residue classes with fixed rep's
##
InstallMethod( ViewString,
 "for residue classes with fixed rep's (ResClasses)", true,
 [ IsResidueClassWithFixedRep ], 0,
 cl -> Concatenation("[",ViewString(Residue(cl)),"/",
 ViewString(Modulus(cl)),"]") );

#############################################################################
##
#M ViewObj( ) . . . . . . for unions of residue classes with fixed rep's
##
InstallMethod( ViewObj,
 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U )

 local R, classes, l, i, short;

 short := RESCLASSES_VIEWINGFORMAT = "short";
 R := UnderlyingRing(FamilyObj(U));
 classes := Classes(U); l := Length(classes);
 if l = 0 or l > 8 or IsPolynomialRing(R) and l > 3 then
 if l = 0 then
 if not short then
 Print("Empty union of residue classes of ",RingToString(R),
 " with fixed representatives");
 else
 Print("[]");
 fi;
 else
 Print("<union of ",l," residue classes");
 if not short
 then Print(" of ",RingToString(R)," with fixed representatives>");
 else Print(" with fixed rep's>"); fi;
 fi;
 else
 for i in [1..l] do
 if i > 1 then Print(" U "); fi;
 Print("[",classes[i][2],"/",classes[i][1],"]");
 od;
 fi;
 end );

#############################################################################
##
#M String( ) . . . . . . for unions of residue classes with fixed rep's
##
InstallMethod( String,
 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U )

 local R, classes;

 R := UnderlyingRing(FamilyObj(U)); classes := Classes(U);
 if Length(classes) = 1 then
 return Concatenation("ResidueClassWithFixedRepresentative( ",
 String(R),", ",String(classes[1][1]),", ",
 String(classes[1][2])," )");
 else
 return Concatenation("UnionOfResidueClassesWithFixedRepresentative",
 "s( ",String(R),", ",String(classes)," )");
 fi;
 end );

#############################################################################
##
#M PrintObj( ) . . . . . for unions of residue classes with fixed rep's
##
InstallMethod( PrintObj,
 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U )

 local R, classes;

 R := UnderlyingRing(FamilyObj(U)); classes := Classes(U);
 if Length(classes) = 1 then
 Print("ResidueClassWithFixedRepresentative( ",R,", ",
 classes[1][1],", ",classes[1][2]," )");
 else
 Print("UnionOfResidueClassesWithFixedRepresentatives( ",R,", ",
 classes," )");
 fi;
 end );

#############################################################################
##
#M Display( ) . . . . . . for unions of residue classes with fixed rep's
##
InstallMethod( Display,
 "for unions of residue classes with fixed rep's (ResClasses)",
 true, [ IsUnionOfResidueClassesWithFixedRepresentatives ], 0,

 function ( U )

 local R, classes, l, i;

 R := UnderlyingRing(FamilyObj(U));
 classes := Classes(U); l := Length(classes);
 if l = 0 then View(U); else
 for i in [1..l] do
 if i > 1 then Print(" U "); fi;
 Print("[",classes[i][2],"/",classes[i][1],"]");
 od;
 fi;
 Print("\n");
 end );

#############################################################################
##
#E fixedrep.gi . . . . . . . . . . . . . . . . . . . . . . . . . . ends here

Quelle fixedrep.gi Sprache: unbekannt

[ Dauer der Verarbeitung: 0.108 Sekunden (vorverarbeitet) ]