Quelle geometry.gi Sprache: unbekannt

#############################################################################
##
## geometry.gi FinInG package
## John Bamberg
## Anton Betten
## Jan De Beule
## Philippe Cara
## Michel Lavrauw
## Max Neunhoeffer
##
## Copyright 2018 Colorado State University
## Sabancı Üniversitesi
## Università degli Studi di Padova
## Universiteit Gent
## University of St. Andrews
## University of Western Australia
## Vrije Universiteit Brussel
##
##
## Implementation stuff for geometries.
##
#############################################################################

#############################################################################
# General methods for incidence structures.
#############################################################################

# CHECKED 14/11/2011 jdb
# 140813 modified by pc : TypesOfIncidenceStructure
#############################################################################
#O IncidenceStructure( <eles>, <inc>, <typ>, <typeset> )
# method for IncidenceStructure.
##
InstallMethod( IncidenceStructure,
"for a set, incidence, type function and type set",
[ IsList, IsFunction, IsFunction, IsList ],
function( eles, inc, typ, typeset )
 local geo, ty, t, typesetstrings, typesetstringsplural;
 geo := rec( elements := eles, increl := inc,
 typefun := typ, typeset := typeset );
 ty := NewType( GeometriesFamily,
 IsIncidenceStructure and IsIncidenceStructureRep );
 typesetstrings:=[];
 typesetstringsplural:=[];
 for t in typeset do
 Add(typesetstrings, Concatenation("element of type ", String(t)));
 Add(typesetstringsplural, Concatenation("elements of type ", String(t)));
 od;
 ObjectifyWithAttributes( geo, ty, RankAttr, Size(typeset), TypesOfElementsOfIncidenceStructure,
 typesetstrings, TypesOfElementsOfIncidenceStructurePlural, typesetstringsplural);
 return geo;
end );

# CHECKED 18/4/2011 jdb
#############################################################################
#O Rank( )
# generic method that calls RankAttr to return the rank of a particular
# incidence structure.
##
InstallMethod( Rank,
"for IsIncidenceStructure",
[IsIncidenceStructure],
i -> RankAttr(i) );

# added 140901, pc
#############################################################################
#O IncidenceGraph( <incstr> )
# Generic method for incidence graph, with trivial group
##
InstallMethod( IncidenceGraph,
 "for an incidence structure",
 [ IsIncidenceStructure ],
 function( incstr )
 local all, adj, gamma;
 if IsBound(incstr!.IncidenceGraphAttr) then
 return incstr!.IncidenceGraphAttr;
 fi;
 all:=List([1..Rank(incstr)], i -> AsSet(ElementsOfIncidenceStructure(incstr,i)));
 all:=Union(all);
 adj:=function(i,j)
 if i=j then
 return false; # Otherwise problem with loops
 else
 return IsIncident(all[i],all[j]);
 fi;
 end;
 gamma := Graph( Group(()), [1..Size(all)], OnPoints, adj, true);
 Setter( IncidenceGraphAttr )( incstr, gamma );
 return gamma;
 end );

#############################################################################
# Elements of incidence structures.
#############################################################################

######################################################################
##
## The following operations just make "nice" versions of functions for
## specific geometries when the corresponding functions are defined.
## this means: methods for the functions here are generic and relying
## on installed methods for more particular objects.
##
######################################################################

#############################################################################
#O ElementsOfIncidenceStructure( <inc>, <j> )
# returns the elements of the incidence structure <inc> of type <j>
##
InstallMethod( ElementsOfIncidenceStructure,
 "for an incidence structure and a type",
[IsIncidenceStructure, IsPosInt],
function( inc, j )
 local r;
 r := Rank(inc);
 if j > r then
 Error("<inc> has no elements of type <j>");
 else
 return Objectify(
 NewType( ElementsCollFamily, IsElementsOfIncidenceStructure and IsElementsOfIncidenceStructureRep ),
 rec( geometry := inc,
 type := j )
 );
 fi;
end);

# CHECKED 18/4/2011 jdb
#############################################################################
#O ElementsOfIncidenceStructure( <ps>, <str> )
# returns the elements of an incidence structure <ps> provided there is an
# installed method for ElementsOfIncidenceStructure for the particular <ps>
# and <str> is occuring in TypesOfElementsOfIncidenceStructurePlural(<ps>).
##
InstallMethod( ElementsOfIncidenceStructure,
"for an incidence structure and a string",
[IsIncidenceStructure, IsString],
function( ps, str )
 local m;
 m := Position(TypesOfElementsOfIncidenceStructurePlural(ps), str);
 if m = fail then
 Error("No such element type!");
 else
 return ElementsOfIncidenceStructure(ps, m);
 fi;
 end);

# added 140813, pc
#############################################################################
#O Iterator( <vs> )
# Iterator for ElementsOfIncidenceStructure of a given type.
##
InstallMethod( Iterator,
 "for IsElementsOfIncidenceStructure",
 [ IsElementsOfIncidenceStructure ],
 function( vs )
 local incstr, elements, wrapped, type;
 incstr := vs!.geometry;
 type := vs!.type;
 elements:=Filtered(incstr!.elements, e -> Position(incstr!.typeset,incstr!.typefun(e)) = type);
 wrapped:=List(elements, e -> Wrap(incstr, type, e));
 return IteratorList(wrapped);
 end );

# CHECKED 4/9/2011 jdb
# but maybe to be changed later on. See to do list on top of file.
#############################################################################
#O Enumerator( <D> )
# generic method that enumerates D, using an Iterator for D
# assuming D belongs to IsElementsOfIncidenceStructure
##
InstallMethod( Enumerator,
"generic method for IsElementsOfIncidenceStructure",
[ IsElementsOfIncidenceStructure ],
function ( D )
local iter, elms;
iter := Iterator( D );
elms := [ ];
while not IsDoneIterator( iter ) do
 Add( elms, NextIterator( iter ) );
od;
return elms;
end);

#############################################################################
#O NrElementsOfIncidenceStructure( <ps>, <str> )
# returns the number of elements of an incidence structure <ps> provided there
# is an installed method for ElementsOfIncidenceStructure for the
# particular <ps> and <str> is occuring in
# TypesOfElementsOfIncidenceStructurePlural(<ps>).
##
InstallMethod( NrElementsOfIncidenceStructure,
"for an incidence structure and a string",
[IsIncidenceStructure, IsString],
function( ps, str )
 return Size(ElementsOfIncidenceStructure(ps, str));
 end);

#############################################################################
#O NrElementsOfIncidenceStructure( <ps>, <typ> )
# returns the number of elements of an incidence structure <ps> provided there
# is an installed method for ElementsOfIncidenceStructure for the
# particular <ps>.
##
InstallMethod( NrElementsOfIncidenceStructure,
"for an incidence structure and a type",
[IsIncidenceStructure, IsPosInt],
function( ps, typ )
 return Size(ElementsOfIncidenceStructure(ps, typ));
 end);

#############################################################################
# Hash functions for elements are important to use the orb package to compute
# orbits (quickly). We implement hash functions for elements and sets of elements.
# Note that the hash functions for elements rely on the hash functions for the underlying
# object. For cvec/cmats, such hash functions are provided in the package cvec of course
#
# The idea for a hashfunction of a set of elements is as follows: if set has length n,
# then we add all hashvalues of the objects in set. The initial length is estimated
# through the orb functionality. So if set has n elements, the resulting value might
# increase the size of a hash table for the individual elements. Therefore we call
# the hash function for the elements with length len/n.
# Note that more clever ideas might lead to faster orbit computation.
##
InstallGlobalFunction( HashFuncForElements,
function( v, data )
 return data.func(v!.obj,data.data);
end );

InstallGlobalFunction( HashFuncForSetElements,
function( v, data )
 return Sum(List(v,x->data.func(x!.obj,data.data)));
end );

InstallMethod( ChooseHashFunction,
"for an element and a hash length",
[ IsElementOfIncidenceStructure, IsPosInt ],
function( v, len )
 local data;
 data := ChooseHashFunction( v!.obj, len );
 return rec( func := HashFuncForElements, data := data );
end );

InstallMethod( ChooseHashFunction,
"for a set of elements and a hash length",
[ CategoryCollections(IsElementOfIncidenceStructure), IsPosInt ],
function( set, len )
 local v,data;
 v := set[1];
 data := ChooseHashFunction( v!.obj, Int(len/Length(set)) );
 return rec( func := HashFuncForSetElements, data := data );
end );

#############################################################################
# General methods for collection of elements of incidence structures.
#############################################################################

# CHECKED 18/04/11 jdb
#############################################################################
#O AmbientGeometry( <x> )
# general method that returns the ambient geometry of a collection of
# elements of a particular type.
# notice the small difference with the previous method :-)
##
InstallMethod( AmbientGeometry,
[ IsElementsOfIncidenceStructure and IsElementsOfIncidenceStructureRep ],
x -> x!.geometry );

# CHECKED 18/04/11 jdb
#############################################################################
#O AmbientGeometry( <x> )
# general method that returns the ambient geometry of a collection of elements
##
InstallMethod( AmbientGeometry,
[ IsAllElementsOfIncidenceStructure ],
x -> x!.geometry );

# CHECKED 14/4/2011 jdb
#############################################################################
#O Type( <x> )
# general method that returns the type of a collection of elements of a particular type.
##
InstallMethod( Type,
"for IsElementsOfIncidenceStructure(Rep)",
[IsElementsOfIncidenceStructure and IsElementsOfIncidenceStructureRep],
x -> x!.type );

#############################################################################
# General methods for particular elements of incidence structures.
#############################################################################

# CHECKED 18/04/11 jdb
# 140813 pc Changed filter for geo to IsIncidenceStructure (was
# IsIncidenceGeometry)
#############################################################################
#O Wrap( <geo>, <type>, <o> )
# general method that just wraps the data (<o>) as an element of a incidence geometry.
# does not do any checking. <geo> and <type> are obviously also arguments.
# Not for users, not documented. More particular wrap methods can be derived from this.
##
InstallMethod( Wrap,
"for a geometry and an object",
[IsIncidenceStructure, IsPosInt, IsObject],
function( geo, type, o )
 local w;
 w := rec( geo := geo, type := type, obj := o );
 Objectify( NewType( ElementsOfIncidenceStructureFamily,
 IsElementOfIncidenceStructure and IsElementOfIncidenceStructureRep ), w );
 return w;
end );

# CHECKED 17/04/11 jdb
#############################################################################
#O Unwrap( <v> )
# general method that returns the data of an element <v>.
# Not for users, not documented.
##
InstallMethod( Unwrap,
"for an element",
[IsElementOfIncidenceStructure and IsElementOfIncidenceStructureRep],
function( v )
 return v!.obj;
end );

#jdb 30/10/15: This method is not used anymore after commenting out the Unwrapper stuff in geometry.gd
#see the comment there.
# CHECKED 17/04/11 jdb
#InstallMethod( \^,
# "for an element of a incidence structure and an unwrapper",
# [IsElementOfIncidenceStructure, IsUnwrapper ],
# function( x, u )
# return x!.obj;
# end );

# added 3/9/14 jdb
#############################################################################
#O UnderlyingObject( <x> )
# general method that returns the ambient geometry of a particular element.
##
InstallMethod( UnderlyingObject,
 "for an element of an incidence structure",
[ IsElementOfIncidenceStructure and IsElementOfIncidenceStructureRep ],
x -> x!.obj );

# added 3/9/14 jdb
#############################################################################
#O ObjectToElement( <inc>, <type>, <obj> )
# general method that returns the element of type represtented by obj.
##
InstallMethod( ObjectToElement,
 "for an incidence structure, a type, and an object",
[ IsIncidenceStructure, IsPosInt, IsObject ],
function(inc,t,obj)
 local typeset;
 typeset := inc!.typeset;
 if not t in typeset then
 Error("<t> is not a type of elements of <inc>");
 elif not obj in inc!.elements then
 Error("<t> does not represent any element of <inc>");
 elif not inc!.typefun(obj) = t then
 Error("<obj> does not represent an element of type <t>");
 else
 return Wrap(inc,t,obj);
 fi;
 end );

# CHECKED 18/04/11 jdb
#############################################################################
#O AmbientGeometry( <x> )
# general method that returns the ambient geometry of a particular element.
##
InstallMethod( AmbientGeometry,
[ IsElementOfIncidenceStructure and IsElementOfIncidenceStructureRep ],
x -> x!.geo );

# CHECKED 27/6/2011 jdb and pc
#############################################################################
#O Intersection2( <el1>, <el2> )
# method for Intersection2, referring to Meet.
##
InstallOtherMethod( Intersection2,
"for two elements of an incidence structure, relying on Meet",
[IsElementOfIncidenceStructure, IsElementOfIncidenceStructure],
function( el1, el2 )
 return Meet(el1,el2);
end);

# CHECKED 14/4/2011 jdb
#############################################################################
#O Type( <x> )
# general method that returns the type of a particular element.
##
InstallMethod( Type,
[ IsElementOfIncidenceStructure and IsElementOfIncidenceStructureRep ],
x -> x!.type );

# CHECKED 18/4/2011 jdb
#############################################################################
#O \=( <a>, )
# test equality method for elements of an incidence structure
# relies to testing equality of underlying 'obj' fields of the arguments.
##
InstallMethod( \=,
"for two IsElementOfIncidenceStructure",
[IsElementOfIncidenceStructure, IsElementOfIncidenceStructure],
function( a, b )
 return a!.obj = b!.obj;
end );

# CHECKED 18/4/2011 jdb, but also changed 18/4/2011. Volunteers to check again?
#############################################################################
#O \<( <a>, )
# LT for two elements of an incidence structure.
# first compares types of elements, in case of equality,
# relies to comparing underlying 'obj' fields of the arguments.
##
InstallMethod( \<, "for two IsElementOfIncidenceStructure",
[IsElementOfIncidenceStructure, IsElementOfIncidenceStructure],
function( a, b )
 if a!.type = b!.type then
 return a!.obj < b!.obj;
 else
 return a!.type < b!.type;
 fi;
end );

# CHECKED 17/04/11 jdb
#############################################################################
#O \*( <a,b> )
# Alternative for IsIncident.
# Remind that IsIncident is an operation declared for elements of any incidence
# structure.
##
InstallOtherMethod( \*,
"for two elements of an incidence structure",
[IsElementOfIncidenceStructure, IsElementOfIncidenceStructure],
function( a, b )
 return IsIncident(b, a);
end );

# added by pc 140813
############################################################################
#O IsIncident( <x,y> )
# For two elements of an incidence structure, generic.
##
InstallMethod( IsIncident,
 "for two elements of an incidence structure",
 [IsElementOfIncidenceStructure, IsElementOfIncidenceStructure],
 function( x, y )
 local geo;
 if AmbientGeometry(x) <> AmbientGeometry(y) then
 Error("Elements must have the same ambient geometry.");
 fi;
 geo:=AmbientGeometry(x);
 return geo!.increl(x!.obj,y!.obj);
 end );

#############################################################################
# General methods for flags of incidence structures.
#############################################################################

# added by pc 140813
# changed by jdb 161214 (added check after test).
#############################################################################
#O FlagOfIncidenceStructure( <incgeo>, <els> )
# returns the flag of the incidence structure <incgeo> with elements in
# the list <els>.
# the method checks whether the input really determines a flag.
##
InstallMethod( FlagOfIncidenceStructure,
 "for an incidence structure and a list of elements",
 [ IsIncidenceStructure, IsElementOfIncidenceStructureCollection ],
 function(incgeo,els)
 local list,i,test,type,flag;
 list := Set(ShallowCopy(els));
 if Length(list) > Rank(incgeo) then
 Error("A flag can contain at most Rank(<incstr>) elements");
 fi;
 test := List(list,x->AmbientGeometry(x));
 if not ForAll(test,x->x=incgeo) then
 Error("not all elements have <incgeo> as ambient geometry");
 fi;
 #if test[1] <> incgeo then
 # Error("<els> is not a list of elements of <incgeo>");
 #fi;
 test := Set(Flat(List([1..Length(list)-1],i ->
 List([i..Length(list)], j -> IsIncident(list[i], list[j])))));
 if (test <> [ true ] and test <> []) then
 Error("<els> does not determine a flag>");
 fi;
 flag := rec(geo := incgeo, types := List(list,x->x!.type),
 els := list);
 ObjectifyWithAttributes(flag,
 IsFlagOfIncidenceStructureType, IsEmptyFlag, false, RankAttr,
 Size(list));
 return flag;
 end);

# added by pc 140901
#############################################################################
#O FlagOfIncidenceStructure( <incgeo>, <els> )
# returns the empty flag of incidence sturcture <incgeo>.
##
InstallMethod( FlagOfIncidenceStructure,
 "for an incidence structure and an empty list",
 [ IsIncidenceStructure, IsList and IsEmpty ],
 function(incgeo,els)
 local flag;
 flag := rec(geo := incgeo, types := [], els := []);
 ObjectifyWithAttributes(flag,
 IsFlagOfIncidenceStructureType, IsEmptyFlag, true, RankAttr, 0);
 return flag;
 end);

# CHECKED 18/4/2011 jdb
#############################################################################
#A IsChamberOfIncidenceStructure( <flag> )
# returns true if <flag> is a chamber.
# remind that flags of projective spaces, polar spaces are constructed in
# IsFlagOfIncidenceStructureRep, which makes this method generic
##
InstallMethod( IsChamberOfIncidenceStructure,
"for a flag of an incidence structure",
[ IsFlagOfIncidenceStructure and IsFlagOfIncidenceStructureRep ],
flag -> Length(flag!.types) = Rank(flag!.geo)
);

# added 140813 pc
#############################################################################
#O AmbientGeometry( <x> )
# general method that returns the ambient geometry of a flag
##
InstallMethod( AmbientGeometry,
 [ IsFlagOfIncidenceStructure and IsFlagOfIncidenceStructureRep],
 x -> x!.geo );

# added by pc, moved to here 31/3/14
#############################################################################
#O ElementsOfFlag( <flag> )
# returns elements of a flag
#
##
InstallMethod( ElementsOfFlag,
"for an incidence structure flag",
[ IsFlagOfIncidenceStructure and IsFlagOfIncidenceStructureRep ],
function(flag)
 return flag!.els;
end );

# added by pc, 140813
#############################################################################
#O Size( <flag> )
# returns size of a flag
#
##
InstallMethod( Size,
 "for an incidence structure flag",
 [ IsFlagOfIncidenceStructure and IsFlagOfIncidenceStructureRep ],
 function(flag)
 return Size(ElementsOfFlag(flag));
 end );

# added by pc, 140901
#############################################################################
#O Rank( <flag> )
# returns rank of a flag
#
##
InstallMethod( Rank,
 "for IsFlagOfIncidenceStructure",
 [ IsFlagOfIncidenceStructure ],
 i -> RankAttr(i) );

# Added 140813, pc
#############################################################################
#O Type( <x> )
# general method that returns the type of a flag
##
InstallMethod( Type,
 "for IsElementsOfIncidenceStructure(Rep)",
 [ IsFlagOfIncidenceStructure and IsFlagOfIncidenceStructureRep ],
 x -> Set(x!.els,Type) );

# added 140813, pc
#############################################################################
#O ResidueOfFlag( <flag> )
# completely generic residue computation
##
InstallMethod( ResidueOfFlag,
 "for a flag",
 [ IsFlagOfIncidenceStructure ],
 function( flag )
 local ambigeo, geo, typfun, typset, resrank, eles, inc;
 ambigeo:=AmbientGeometry(flag);
 typset:=Difference([1..Rank(ambigeo)], Type(flag));
 resrank:=Size(typset);
 typfun:=function(ele)
 return Position(typset, Type(ele));
 end;
 eles:=List(typset, j -> List(ShadowOfFlag(ambigeo,flag,j)));
 inc:=function(x,y)
 return IsIncident(x,y);
 end;
 geo := IncidenceStructure(Union(eles), inc, typfun, [1..resrank]);
 SetAmbientGeometry(geo,ambigeo);
 return geo;
end );

#############################################################################
# methods that allow us to make an ordered Set from a list of flags,
# and to make an ordered Set of a list of elements and flags.
#############################################################################

# added 2/9/14 pc+jdb
#############################################################################
#O \=( <a>, )
# test equality method for flags of an incidence structure
# relies to testing equality of underlying 'obj' fields of the arguments.
##
InstallMethod( \=,
"for two IsElementOfIncidenceStructure",
[ IsFlagOfIncidenceStructure, IsFlagOfIncidenceStructure ],
function( a, b )
 return Set(a!.els) = Set(b!.els);
end );

# added 2/9/14 pc+jdb
#############################################################################
#O \<( <a>, )
# LT for two flags of an incidence structure.
# first compares types of elements, in case of equality,
# relies to comparing underlying 'obj' fields of the arguments.
##
InstallMethod( \<, "for two IsFlagOfIncidenceStructure",
[ IsFlagOfIncidenceStructure, IsFlagOfIncidenceStructure ],
function( a, b )
 if a!.types = b!.types then
 return a!.els < b!.els;
 else
 return a!.types < b!.types;
 fi;
end );

# added 2/9/14 pc+jdb
#############################################################################
#O \<( <a>, )
# LT for a flag and an element.
# first compares types of elements, in case of equality,
# relies to comparing underlying 'obj' fields of the arguments.
##
InstallMethod( \<, "for two IsElementOfIncidenceStructure",
[ IsFlagOfIncidenceStructure, IsElementOfIncidenceStructure ],
function( a, b )
 if a!.geo <> b!.geo then
 Error("<flag> and <element> do not belong to the same geometry");
 fi;
 return false;
 end );

# added 2/9/14 pc+jdb
#############################################################################
#O \<( <a>, )
# LT for two flags of an incidence structure.
# first compares types of elements, in case of equality,
# relies to comparing underlying 'obj' fields of the arguments.
##
InstallMethod( \<, "for two IsElementOfIncidenceStructure",
[ IsElementOfIncidenceStructure, IsFlagOfIncidenceStructure ],
function( a, b )
 if a!.geo <> b!.geo then
 Error("<element> and <flag> do not belong to the same geometry");
 fi;
 return true;
 end );

# added by pc 140813
############################################################################
#O IsIncident( <x,F> )
# For an element and a flag of an incidence structure
# An element is incident with a flag if it is incident with all elements
# of the flag.
##
InstallMethod( IsIncident,
 "for an element and a flag of an incidence structure",
 [ IsElementOfIncidenceStructure, IsFlagOfIncidenceStructure ],
 function( x, f )
 local iter, inc;
 iter:=Iterator(ElementsOfFlag(f));
 inc:=true;
 while inc and not(IsDoneIterator(iter)) do
 inc:=IsIncident(x,NextIterator(iter));
 od;
 return inc;
 end );

# added by pc 140813
############################################################################
#O IsIncident( <x,F> )
# For an element and a flag of an incidence structure
# An element is incident with a flag if it is incident with all elements
# of the flag.
##
InstallMethod( IsIncident,
 "for an element and a flag of an incidence structure",
 [IsFlagOfIncidenceStructure, IsElementOfIncidenceStructure],
 function( f, x )
 local iter, inc;
 iter:=Iterator(ElementsOfFlag(f));
 inc:=true;
 while inc and not(IsDoneIterator(iter)) do
 inc:=IsIncident(x,NextIterator(iter));
 od;
 return inc;
 end );

#############################################################################
#O \in( <x>, <y> )
# x: an element of an incidence structure, y a flag of that incidence structure
##
InstallOtherMethod( \in,
"for an element and a flag of an incidence structure",
[ IsElementOfIncidenceStructure, IsFlagOfIncidenceStructure ],
function( x, y )
 if x!.geo <> y!.geo then
 Error( "<x> and <y> have not the same ambient geometry" );
 else
 return x in y!.els;
 fi;
end );

# CHECKED 11/09/11 jdb
# this is a method that is generic for more geometries than projective spaces, so
# this was moved from projectivespace.gi to geometry.gi on 5/4/2018.
#############################################################################
#O \in( <x>, <dom> )
# returns true if <x> belongs to the elements collected in <dom> It is checked if their
# geometry matches.
##
InstallMethod( \in,
 "for an element and domain",
 # 1*SUM_FLAGS+3 increases the ranking for this method
 # 5/4/2018: jdb wonders if the above line is necessary.
 [IsElementOfIncidenceStructure, IsAllElementsOfIncidenceStructure], 1*SUM_FLAGS+3,
 function( x, dom )
 return x in dom!.geometry;
 end );

# CHECKED 11/09/11 jdb
# this was moved from projectivespace.gi to geometry.gi on 5/4/2018.
#############################################################################
#O \in( <x>, <dom> )
# returns true if <x> belongs to the elements collected in <dom> It is checked if their
# geometry matches.
##
InstallMethod( \in,
 "for an element and set of elements of an incidence structure",
 # 1*SUM_FLAGS+3 increases the ranking for this method
 # 5/4/2018: jdb wonders if the above line is necessary.
 [IsElementOfIncidenceStructure, IsElementsOfIncidenceStructure], 1*SUM_FLAGS+3,
 function( x, dom )
 return x in dom!.geometry and x!.type = dom!.type;
 end );

# new since 5/4/2018 jdb
# this was necessary, since the above method causes prblems when dom is
# IsShadowElementsOf...
# this new method is generic. Since e.g. IsShadowSubspacesOfProjectiveSpace
# is not a subcategory of IsShadowElementsOfIncidenceStructure, we have
# to create an operation for Lie geometries (and probably others) as well.
#############################################################################
#O \in( <x>, <dom> )
# returns true if <x> belongs to the elements collected in <dom> It is checked if their
# geometry matches.
##
#InstallMethod( \in,
# "for an element and collection of shadow elements of an incidence structure",
 # 1*SUM_FLAGS+3 increases the ranking for this method
 # 5/4/2018: jdb wonders if the above line is necessary.
# [IsElementOfIncidenceStructure, IsShadowElementsOfIncidenceStructure], 1*SUM_FLAGS+3,
# function( x, dom )
# return x in dom!.geometry and x!.type = dom!.type and IsIncident(x,dom!.flag); #there is no representation declared for IsShadowElementsOfIncidenceStructure, so we have no idea whether a flag is available.
# end );

#############################################################################
# General methods for shadows of elements/flags
#############################################################################

# added by pc 140901
############################################################################
#O ShadowOfElement( <inc>, <f> ,<j> )
# Completely generic shadow computation
# For an element of an incidence structure and a type j
# Returns all elements of type j which are incident to e
##
InstallMethod( ShadowOfElement,
 "for an element of an incidence structure and a type",
 [IsIncidenceStructure, IsElementOfIncidenceStructure, IsPosInt],
 function( inc, f, j )
 local iter, shad, x;
 return Objectify( NewType( ElementsCollFamily, IsElementsOfIncidenceStructure and
 IsShadowElementsOfIncidenceStructure),
 rec( geometry := inc,
 type := j,
 parentflag := FlagOfIncidenceStructure(inc,[f]) )
 );
 end );

# CHECKED 18/4/2011 jdb
#############################################################################
#O ShadowOfElement( <ps>, <v>, <str> )
# returns the shadow elements of type <str> in element <v> in the inc str <ps>
# relies on installed method for ShadowOfElement for the particular <ps>
# and <str> is occuring in TypesOfElementsOfIncidenceStructurePlural(<ps>).
##
InstallMethod( ShadowOfElement,
"for an incidence structure, an element of, and a string",
[IsIncidenceStructure, IsElementOfIncidenceStructure, IsString],
function( ps, v, str )
 local m;
 m := Position(TypesOfElementsOfIncidenceStructurePlural(ps), str);
 if m = fail then
 Error("No such element type!");
 else
 return ShadowOfElement(ps, v, m);
 fi;
 end);

# CHECKED 19/4/2011 jdb
# moved to geometry.gi and made generic 3/9/14
#############################################################################
#O ElementsIncidentWithElementOfIncidenceStructure( <el>, )
# returns the elements of type in <el>, relying on ShadowOfElement
# for particular <el>.
##
InstallMethod( ElementsIncidentWithElementOfIncidenceStructure, "for IsElementOfLieGeometry",
[ IsElementOfIncidenceStructure, IsPosInt],
function( el, i )
 return ShadowOfElement(el!.geo, el, i);
end );

# added by pc 140813
############################################################################
#O ShadowOfFlag( <F,j> )
# Completely generic shadow computation
# For a flag of an incidence structure and a type j
# Returns all elements of type j which are incident to the flag F
##
InstallMethod( ShadowOfFlag,
 "for an incidence structure, flag of an incidence structure and a type",
 [IsIncidenceStructure, IsFlagOfIncidenceStructure, IsPosInt],
 function( inc, f, j )
 local iter, shad, x;
 return Objectify( NewType( ElementsCollFamily, IsElementsOfIncidenceStructure and
 IsShadowElementsOfIncidenceStructure),
 rec( geometry := inc,
 type := j,
 parentflag := f )
 );
 end );

# CHECKED 18/4/2011 jdb
#############################################################################
#O ShadowOfFlag( <ps>, <v>, <str> )
# returns the shadow elements of <flag>, i.e. the elements of <ps> of type <j>
# incident with all elements of <flag>.
# relies on installed method for ShadowOfElement for the particular <ps>
# and <str> is occuring in TypesOfElementsOfIncidenceStructurePlural(<ps>).
##
InstallMethod( ShadowOfFlag,
"for an incidence structure, a flag, and a string",
[IsIncidenceStructure, IsFlagOfIncidenceStructure, IsString],
function( ps, vs, str )
 local m;
 m := Position(TypesOfElementsOfIncidenceStructurePlural(ps), str);
 if m = fail then
 Error("No such element type!");
 else
 return ShadowOfFlag(ps, vs, m);
 fi;
end);

# CHECKED 27/4/2011 jdb
#############################################################################
#O ShadowOfFlag( <ps>, <list>, <j> )
# returns the shadow elements of the flag <list>, provided <list> determines
# a flag in <ps>. Relies completely on FlagOfIncidenceStructure for <ps>,
# so this implementation is generic.
##
InstallMethod( ShadowOfFlag,
"for an incidence structure, a list, and an integer",
[IsIncidenceStructure, IsList, IsPosInt],
function( ps, list, j )
 return ShadowOfFlag(ps,FlagOfIncidenceStructure(ps,list),j);
end);

# CHECKED 27/4/2011 jdb
#############################################################################
#O ShadowOfFlag( <ps>, <list>, <str> )
# returns the shadow elements of the flag <list>, provided <list> determines
# a flag in <ps>. Relies completely on FlagOfIncidenceStructure for <ps>,
# and on ShadowOfFlag for <ps> <v> and <str>, so this implementation is generic.
##
InstallMethod( ShadowOfFlag,
"for an incidence structure, a list, and an integer",
[IsIncidenceStructure, IsList, IsString],
function( ps, list, str )
 return ShadowOfFlag(ps,FlagOfIncidenceStructure(ps,list),str);
end);

# added by pc 140901
#############################################################################
#O Iterator( <vs>)
# returns an iterator for <vs>, a collection of shadow elemenst of an incidence structure
##
InstallMethod( Iterator,
"for shadow elements of an incidence structure",
[ IsShadowElementsOfIncidenceStructure ],
function( vs )
 local j, f, shad, x, iter;
 f := vs!.parentflag;
 j := vs!.type;
 if j in Type(f) then
 return IteratorList([f!.els[Position(Type(f),j)]]);
 fi;
 iter:=Iterator(ElementsOfIncidenceStructure(vs!.geometry,j));
 shad:=[];
 for x in iter do
 if IsIncident(x,f) then Add(shad,x); fi;
 od;
 return IteratorList(shad);
 end );

#############################################################################
# Viewing/Printing/Displaying methods.
#############################################################################
# 5 CHECKED 4/09/11 jdb

InstallMethod( ViewObj,
"for IsElementOfIncidenceStructure",
[ IsElementOfIncidenceStructure and IsElementOfIncidenceStructureRep ],
function( v )
 Print("<a ",TypesOfElementsOfIncidenceStructure(v!.geo)[v!.type]," in ");
 ViewObj(v!.geo);
 Print(">");
end );

InstallMethod( ViewObj,
 "for IsFlagOfIncidenceStructure",
 [ IsFlagOfIncidenceStructure and IsFlagOfIncidenceStructureRep ],
 function( v )
 Print("<a flag of ");
 ViewObj(v!.geo);
 Print(">");
 end );

InstallMethod( PrintObj,
"for IsElementOfIncidenceStructure",
[ IsElementOfIncidenceStructure and IsElementOfIncidenceStructureRep ],
function( v )
 Print( v!.obj );
end );

InstallMethod( Display,
"for IsElementOfIncidenceStructure",
[ IsElementOfIncidenceStructure and IsElementOfIncidenceStructureRep ],
function( v )
 Display(v!.obj);
end );

# JB (31/01/2013): One thing that I would like in GAP is to have Display for vectors just
# like that for matrices. So here is a method which makes this happen
# JDB: I agree, but this causes problems, see remark of Alexander of 8/12/14.
#InstallMethod( Display,
# "for IsVector",
# [ IsVector ],
# function( v )
# Display( [v] );
# end );

InstallMethod( ViewObj,
"for IsAllElementsOfIncidenceStructure",
[ IsAllElementsOfIncidenceStructure ],
function( vs )
 Print("<Elements of ");
 ViewObj(vs!.geometry);
 Print(">");
end );

InstallMethod( PrintObj,
"for IsAllElementsOfIncidenceStructure",
[ IsAllElementsOfIncidenceStructure ],
function( vs )
 Print("ElementsOfIncidenceStructure( ",vs!.geometry," )");
end );

# Finally a generic ViewObj method for shadow elements.
#############################################################################
InstallMethod( ViewObj,
"for shadow elements of a Lie geometry",
[ IsShadowElementsOfIncidenceStructure ],
function( vs )
 Print("<shadow elements of type ", vs!.type," in ");
 ViewObj(vs!.geometry);
 Print(">");
end );

InstallMethod( ViewObj,
"for IsElementsOfIncidenceStructure",
[ IsElementsOfIncidenceStructure ],
function( vs )
 Print("<Elements of type ", vs!.type," of ");
 ViewObj(vs!.geometry);
 Print(">");
end );

InstallMethod( PrintObj,
"for IsElementsOfIncidenceStructure",
[ IsElementsOfIncidenceStructure ],
function( vs )
 Print("ElementsOfIncidenceStructure( ",vs!.geometry," ) of type ",vs!.type);
end );

#############################################################################
# Display methods:
#############################################################################

InstallMethod( ViewObj,
"for an incidence structure",
[ IsIncidenceStructure ],
function(x)
 Print("Incidence structure of rank ", RankAttr(x));
end );

InstallMethod( PrintObj,
"for an incidence structure",
[ IsIncidenceStructure ],
function(x)
 Print("Incidence structure of rank ", RankAttr(x)," with elements of type ",x!.typeset);
end );

InstallMethod( Display,
"for an incidence structure",
[ IsIncidenceStructure ],
function(x)
 Print("Incidence structure of rank ", RankAttr(x)," with elements of type ",x!.typeset);
end );

#############################################################################
# methods for the two general properties
# We are gratefull to Harald Gropp for pointing out the difference clearly
# between a configuration and a constellation during the conference
# Combinatorics 2014.
#############################################################################

InstallMethod( IsConfiguration,
 "for an incidence structure",
 [ IsIncidenceStructure],
 function(x)
 Info(InfoFinInG, 2, "The authors are grateful to Harald Gropp for pointing out clearly the difference between a configuration and a constellation.");
 return true;
 end );

InstallMethod( IsConstellation,
 "for an incidence structure",
 [ IsIncidenceStructure],
 function(x)
 Info(InfoFinInG, 2, "The authors are grateful to Harald Gropp for pointing out clearly the difference between a configuration and a constellation.");
 return true;
 end );

Quelle geometry.gi Sprache: unbekannt

[ Dauer der Verarbeitung: 0.38 Sekunden (vorverarbeitet) ]