Quellcode-Bibliothek srglib.gd Sprache: unbekannt

Untersuchungsergebnis.gd Download desUnknown {[0] [0] [0]}zum Wurzelverzeichnis wechseln

#############################################################################
##
#W srglib.gd Algebraic Graph Theory package Rhys J. Evans
##
##
#Y Copyright (C) 2020
##
## Declaration file for functions involving strongly regular graphs.
##

#############################################################################
##
#F ComplementSRGParameters( <parms> )
##
## <#GAPDoc Label="ComplementSRGParameters">
## <ManSection>
## <Func Name="ComplementSRGParameters"
## Arg='parms'/>
## <Returns>A list.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A>, this
## function returns the complement parameters of <A>parms</A>.
## 
## Suppose <M>\Gamma</M> is a strongly regular graph with parameters
## <M>(v,k,a,b)</M>. Then the complement of <M>\Gamma</M> is a strongly
## regular graph with parameters <M>(v,v-k-1,v-2-2k+b,v-2k+a)</M> (see <Cite Key="BCN_1989"/>).
## We define the <E>complement parameters</E> of the feasible strongly regular
## graph parameter tuple <M>(v,k,a,b)</M> as the tuple <M>(v,v-k-1,v-2-2k+b,v-2k+a)</M>.
## <Example>
## <![CDATA[
##gap> ComplementSRGParameters([16,9,4,6]);
##[ 16, 6, 2, 2 ]
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "ComplementSRGParameters" );

#############################################################################
##
#F IsPrimitiveSRGParameters( [ <v>, <k>, <a>, ] )
##
## <#GAPDoc Label="IsPrimitiveSRGParameters">
## <ManSection>
## <Func Name="IsPrimitiveSRGParameters"
## Arg='[ v, k, a, b ]'/>
## <Returns><K>true</K> or <K>false</K>.</Returns>
##
## <Description>
## Given a list of integers of length 4, <A>[v,k,a,b]</A>, this
## function returns <K>true</K> if <M>(<A>v,k,a,b</A>)</M> is a feasible
## parameter tuple for a primitive strongly regular graph. Otherwise, this
## function returns <K>false</K>.
## 
## Let <M>(v,k,a,b)</M> be feasible strongly regular parameters with
## complement parameters <M>(v',k',a',b')</M>. Then the parameter tuple
## <M>(v,k,a,b)</M> is called <E>primitive</E> if <M>b\not= 0</M> and <M>b'\not= 0</M>.
## 
## A strongly regular graph <M>\Gamma</M> is called <E>primitive</E> if
## <M>\Gamma</M> and its complement is connected. It is known that a
## non-primitive strongly regular graph is a union of cliques, or the
## complement of a union of cliques. From our definition, it follows that a
## strongly regular graph <M>\Gamma</M> is primitive if and only if
## <M>\Gamma</M> has primitive strongly regular graph parameters (see <Cite Key="BCN_1989"/>).
## <Example>
## <![CDATA[
##gap> IsFeasibleSRGParameters([8,6,4,6]);
##true
##gap> IsPrimitiveSRGParameters([8,6,4,6]);
##false
##gap> IsPrimitiveSRGParameters([10,6,3,4]);
##true
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "IsPrimitiveSRGParameters" );

#############################################################################
##
#F IsTypeISRGParameters( [ <v>, <k>, <a>, ] )
##
## <#GAPDoc Label="IsTypeISRGParameters">
## <ManSection>
## <Func Name="IsTypeISRGParameters"
## Arg='[ v, k, a, b ]'/>
## <Returns><K>true</K> or <K>false</K>.</Returns>
##
## <Description>
## Given a list of integers of length 4, <A>[v,k,a,b]</A>, this
## function returns <K>true</K> if <M>(<A>v,k,a,b</A>)</M> is a feasible
## parameter tuple for a type I strongly regular graph. Otherwise, this
## function returns <K>false</K>.
## 
## A feasible strongly regular parameter tuple <M>(v,k,a,b)</M> is of
## <E>type I</E> (or a <E>conference graph</E>) if there exists a positive integer <M>t</M> such that
## <M>v=4t+1,k=2t,a=t-1,b=t</M>.
## 
## There are two types of strongly regular graphs, called type I and
## type II (see <Cite Key="BCN_1989"/>). Let <M>\Gamma</M> be a
## strongly regular graph with parameters <M>(v,k,a,b)</M>. Then <M>\Gamma</M>
## is of <E>type I</E> if and only if <M>(v,k,a,b)</M> is of type I.
## <Example>
## <![CDATA[
##gap> IsTypeISRGParameters([5,2,0,1]);
##true
##gap> IsTypeISRGParameters([9,4,1,2]);
##true
##gap> IsTypeISRGParameters([10,3,0,1]);
##false
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "IsTypeISRGParameters" );

#############################################################################
##
#F IsTypeIISRGParameters( [ <v>, <k>, <a>, ] )
##
## <#GAPDoc Label="IsTypeIISRGParameters">
## <ManSection>
## <Func Name="IsTypeIISRGParameters"
## Arg='[ v, k, a, b ]'/>
## <Returns><K>true</K> or <K>false</K>.</Returns>
##
## <Description>
## Given a list of integers of length 4, <A>[v,k,a,b]</A>, this
## function returns <K>true</K> if <M>(<A>v,k,a,b</A>)</M> is a feasible
## parameter tuple for a type II strongly regular graph. Otherwise, this
## function returns <K>false</K>.
## 
## A feasible strongly regular parameter tuple <M>(v,k,a,b)</M> is of
## <E>type II</E> if the polynomial <M>x^{2}-(a-b)x+b-k</M> has integer zeros.
## 
## There are two types of strongly regular graphs, called type I and
## <E>type II</E> (see <Cite Key="BCN_1989"/>). Let <M>\Gamma</M> be a
## strongly regular graph with parameters <M>(v,k,a,b)</M>. Then <M>\Gamma</M>
## is of <E>type II</E> if and only if all of its eigenvalues are integer.
## The eigenvalues of <M>\Gamma</M> are <M>k</M> and the zeros of the
## polynomial <M>x^{2}-(a-b)x+b-k</M> (see <Cite Key="BCN_1989"/>). From our
## definition, it follows that <M>\Gamma</M> is of type II if and only if
## <M>(v,k,a,b)</M> is of type II.
## <Example>
## <![CDATA[
##gap> IsTypeIISRGParameters([5,2,0,1]);
##false
##gap> IsTypeIISRGParameters([9,4,1,2]);
##true
##gap> IsTypeIISRGParameters([10,3,0,1]);
##true
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "IsTypeIISRGParameters" );

#############################################################################
##
#F SRGToGlobalParameters( <parms> )
##
## <#GAPDoc Label="SRGToGlobalParameters">
## <ManSection>
## <Func Name="SRGToGlobalParameters"
## Arg='parms'/>
## <Returns>A list.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A>, this
## function returns the global parameters of a graph with strongly regular
## graph parameters <A>parms</A>. For information on global parameters of a
## graph, see <Cite Key="GRAPE_2018"/>.
## <Example>
## <![CDATA[
##gap> SRGToGlobalParameters([50,7,0,1]);
##[ [ 0, 0, 7 ], [ 1, 0, 6 ], [ 1, 6, 0 ] ]
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "SRGToGlobalParameters" );

#############################################################################
##
#F GlobalToSRGParameters( <parms> )
##
## <#GAPDoc Label="GlobalToSRGParameters">
## <ManSection>
## <Func Name="GlobalToSRGParameters"
## Arg='parms'/>
## <Returns>A list.</Returns>
##
## <Description>
## Given the global parameters <A>parms</A> of a connected strongly regular graph,
## this function returns the strongly regular graph parameters of the graph.
## For information on global parameters of a graph, see <Cite Key="GRAPE_2018"/>.
## <Example>
## <![CDATA[
##gap> parms:=GlobalParameters(JohnsonGraph(5,3));
##[ [ 0, 0, 6 ], [ 1, 3, 2 ], [ 4, 2, 0 ] ]
##gap> GlobalToSRGParameters(parms);
##[ 10, 6, 3, 4 ]
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "GlobalToSRGParameters" );

#############################################################################
##
#O KreinParameters( [ <v>, <k>, <a>, ] )
##
## <#GAPDoc Label="KreinParameters">
## <ManSection>
## <Oper Name="KreinParameters"
## Arg='[ v, k, a, b ]'/>
## <Returns>A list.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>[v, k, a, b]</A>,
## this function returns a list of (non-trivial) Krein parameters of a
## strongly regular graph with parameters <M>(<A>v,k,a,b</A>)</M>.
## 
## If the eigenvalues of a strongly regular graph are integer, the object
## returned is a list of integers. If the eigenvalues are irrational, the
## object returned will be a list of cyclotomic numbers.
## 
## Let <M>\Gamma</M> be a strongly regular graph with parameters <M>(v,k,a,b)</M>
## and eigenvalues <M>k\geq r > s</M>. Then the <E>Krein parameters</E> of
## <M>\Gamma</M> are the numbers
## <Display>K_{1}=(k+r)(s+1)^{2} - (r+1)(k+r+2rs),</Display><Display>K_{2}=(k+s)(r+1)^{2} - (s+1)(k+s+2rs).</Display>
## For information on the Krein parameters of strongly regular graphs, see <Cite Key="BCN_1989"/>.
## <Example>
## <![CDATA[
##gap> KreinParameters([10,6,3,4]);
##[ 1, 16 ]
##gap> KreinParameters([13,6,2,3]);
##[ -14*E(13)-12*E(13)^2-14*E(13)^3-14*E(13)^4-12*E(13)^5-12*E(13)^6-12*E(13)^7
## -12*E(13)^8-14*E(13)^9-14*E(13)^10-12*E(13)^11-14*E(13)^12,
## -12*E(13)-14*E(13)^2-12*E(13)^3-12*E(13)^4-14*E(13)^5-14*E(13)^6-14*E(13)^7
## -14*E(13)^8-12*E(13)^9-12*E(13)^10-14*E(13)^11-12*E(13)^12 ]
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "KreinParameters" , [IsList]);

#############################################################################
##
#O IsKreinConditionsSatisfied( [ <v>, <k>, <a>, ] )
##
## <#GAPDoc Label="IsKreinConditionsSatisfied">
## <ManSection>
## <Oper Name="IsKreinConditionsSatisfied"
## Arg='[ v, k, a, b ]'/>
## <Returns><K>true</K> or <K>false</K>.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>[v, k, a, b]</A>,
## this function returns <K>true</K> if the parameters satisfy the Krein
## conditions. Otherwise, this function returns <K>false</K>.
## 
## Let <M>\Gamma</M> be a strongly regular graph with parameters <M>(v,k,a,b)</M>
## and Krein parameters <M>K_{1},K_{2}</M> (see <Ref Func="KreinParameters"/>.
## The <E>Krein conditions</E> of <M>\Gamma</M> are the inequalities
## <Display>K_{1}\geq 0, K_{2}\geq 0.</Display>
## It is known that any strongly regular graph must have parameters that satisfy the Krein conditions.
## For information on the Krein conditions of strongly regular graphs, see <Cite Key="BCN_1989"/>.
## <Example>
## <![CDATA[
##gap> IsKreinConditionsSatisfied([28,9,0,4]);
##false
##gap> IsKreinConditionsSatisfied([13,6,2,3]);
##true
##gap> IsKreinConditionsSatisfied([10,6,3,4]);
##true
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareOperation( "IsKreinConditionsSatisfied" , [IsList]);

#############################################################################
##
#F IsAbsoluteBoundSatisfied( [ <v>, <k>, <a>, ] )
##
## <#GAPDoc Label="IsAbsoluteBoundSatisfied">
## <ManSection>
## <Func Name="IsAbsoluteBoundSatisfied"
## Arg='[ v, k, a, b ]'/>
## <Returns><K>true</K> or <K>false</K>.</Returns>
##
## <Description>
## Given primitive strongly regular graph parameters <A>[v, k, a, b]</A>,
## this function returns <K>true</K> if the parameters satisfy the absolute
## bound. Otherwise, this function returns <K>false</K>.
## 
## Let <M>\Gamma</M> be a primitive strongly regular graph with parameters <M>(v,k,a,b)</M>
## and eigenvalues <M>k\geq r > s</M>, with multiplicities <M>1,f,g</M>.
## The <E>absolute bound</E> for the number of vertices of <M>\Gamma</M> is
## <Display>v\leq f(f+3)/2, v\leq g(g+3)/2.</Display>
## For information on the absolute bound of strongly regular graphs, see <Cite Key="BCN_1989"/>.
## <Example>
## <![CDATA[
##gap> IsAbsoluteBoundSatisfied([13,6,3,4]);
##false
##gap> IsAbsoluteBoundSatisfied([50,21,4,12]);
##false
##gap> IsAbsoluteBoundSatisfied([50,21,8,9]);
##true
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "IsAbsoluteBoundSatisfied" );

######################
## GLOBAL VARIABLES ##
######################
##---------------------------------------------------------------------------------------------

#############################################################################
##
#V AGT_Brouwer_Parameters_MAX
##
## <#GAPDoc Label="AGT_Brouwer_Parameters_MAX">
## <ManSection>
## <Var Name="AGT_Brouwer_Parameters_MAX"/>
##
## <Description>
## This variable stores the largest value <M>v</M> for which the current
## package contains information about the parameters of all strongly regular
## graphs with at most <M>v</M> vertices. This information is stored in the
## list <Ref Var="AGT_Brouwer_Parameters"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##DeclareGlobalVariable("AGT_Brouwer_Parameters_MAX","SRG Parameters maximum order from Brouwer");

#############################################################################
##
#V AGT_Brouwer_Parameters
##
## <#GAPDoc Label="AGT_Brouwer_Parameters">
## <ManSection>
## <Var Name="AGT_Brouwer_Parameters"/>
##
## <Description>
## This variable stores information about the feasible strongly regular
## graph parameters found in Brouwer <Cite Key="B_2018"/> and the available strongly regular graphs.
## <A>AGT_Brouwer_Parameters</A> is a list, each element of which is
## a list of length <M>4</M>. For an element <C>[parms,status,stored,num]</C>,
## each entry denotes the following;
## <List>
## <C>parms</C>
## <Item>A feasible strongly regular graph parameter
## tuple <C>[v,k,a,b]</C>, where <A>v</A> is less than <Ref Var="AGT_Brouwer_Parameters_MAX"/>.
## </Item>
## <C>status</C>
## <Item>the status of the known strongly regular
## graphs with parameters <C>parms</C>. This entry is
## <List>
## <Item><M>0</M> if there exists a strongly regular graph with parameters
## <C>parms</C>, and all such graphs have been enumerated,</Item>
## <Item><M>1</M> if there exists a strongly regular graph with parameters
## <C>parms</C>, but all such graphs have not been enumerated,</Item>
## <Item><M>2</M> if it is not known if a strongly regular graph with
## parameters <C>parms</C> exists, </Item>
## <Item><M>3</M> if it has been proven that no strongly regular graph with
## parameters <C>parms</C> exists.</Item>
## </List>
## </Item>
## <C>stored</C>
## <Item>the number of non-isomoprhic
## strongly regular graphs with parameters <C>parms</C> that are
## available in the current package.</Item>
## <C>num</C>
## <Item>
## the number of non-isomorphic
## strongly regular graphs with parameters <C>parms</C> that exist. If this
## has not been determined, the value of <C>num</C> is set to <C>-1</C>.
## </Item>
## </List>
## <Example>
## <![CDATA[
##gap> AGT_Brouwer_Parameters[34];
##[ [ 36, 20, 10, 12 ], 0, 32548, 32548 ]
##gap> AGT_Brouwer_Parameters[35];
##[ [ 37, 18, 8, 9 ], 1, 6760, -1 ]
##gap> AGT_Brouwer_Parameters[2530];
##[ [ 765, 176, 28, 44 ], 2, 0, -1 ]
##gap> AGT_Brouwer_Parameters[4530];
##[ [ 1293, 646, 322, 323 ], 3, 0, 0 ]
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
DeclareGlobalVariable("AGT_Brouwer_Parameters","SRG Parameters from Brouwer");

######################
## GLOBAL FUNCTIONS ##
######################

#############################################################################
##
#F IsSRGAvailable( <parms> )
##
## <#GAPDoc Label="IsSRGAvailable">
## <ManSection>
## <Func Name="IsSRGAvailable"
## Arg='parms'/>
## <Returns><K>true</K> or <K>false</K>.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A>, this
## function returns <K>true</K> if there is a strongly regular graph with
## parameters <A>parms</A> stored in this package. If <A>parms</A> is a
## feasible parameter tuple but there is no strongly regular graphs with
## parameters <A>parms</A> available, the function returns <K>false</K>.
## <Example>
## <![CDATA[
##gap> IsSRGAvailable([28,12,6,4]);
##true
##gap> IsSRGAvailable([28,9,0,4]);
##false
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "IsSRGAvailable" );

#############################################################################
##
#F SRGLibraryInfo( <parms> )
##
## <#GAPDoc Label="SRGLibraryInfo">
## <ManSection>
## <Func Name="SRGLibraryInfo"
## Arg='parms'/>
## <Returns>A list.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A>, with first
## parameter <A>v</A> at most <Ref Var="AGT_Brouwer_Parameters_MAX"/>, this
## function returns the element of <Ref Var="AGT_Brouwer_Parameters"/>
## corresponding to <A>parms</A>.
## <Example>
## <![CDATA[
##gap> SRGLibraryInfo([37,18,8,9]);
##[ [ 37, 18, 8, 9 ], 1, 6760, -1 ]
##gap> SRGLibraryInfo([36,15,6,6]);
##[ [ 36, 15, 6, 6 ], 0, 32548, 32548 ]
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "SRGLibraryInfo" );

#############################################################################
##
#F SRG( <parms> , <n> )
##
## <#GAPDoc Label="SRG">
## <ManSection>
## <Func Name="SRG"
## Arg='parms, n'/>
## <Returns>A record or <K>fail</K>.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A> and positive
## integer <A>n</A>, this function returns the <A>n</A>th strongly regular
## graph with parameters <A>parms</A> available in this package. If there
## there is no <A>n</A>th strongly regular
## graph with parameters <A>parms</A> available, the function returns
## <K>fail</K>.
## <Example>
## <![CDATA[
##gap> SRG([16,6,2,2],1);
##rec( adjacencies := [ [ 2, 3, 4, 5, 6, 7 ] ],
## group := <permutation group with 6 generators>, isGraph := true,
## names := [ 1 .. 16 ], order := 16, representatives := [ 1 ],
## schreierVector := [ -1, 6, 4, 3, 5, 5, 5, 6, 6, 6, 4, 4, 4, 3, 3, 3 ] )
##gap> SRG([16,6,2,2],2);
##rec( adjacencies := [ [ 2, 3, 4, 5, 6, 7 ] ], group := Group([ (3,4)(5,6)(8,9)
## (11,14)(12,13)(15,16), (2,3)(4,5)(6,7)(9,11)(10,12)(14,15), (1,2)(5,8)(6,9)
## (7,10)(11,12)(13,14) ]), isGraph := true, names := [ 1 .. 16 ],
## order := 16, representatives := [ 1 ],
## schreierVector := [ -1, 3, 2, 1, 2, 1, 2, 3, 3, 3, 2, 2, 1, 1, 2, 1 ] )
##gap> SRG([28,9,0,4],1);
##fail
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "SRG" );

##---------------------------------------------------------------------------------------------
#############################################################################
##
#F NrSRGs( <parms> )
##
## <#GAPDoc Label="NrSRGs">
## <ManSection>
## <Func Name="NrSRGs"
## Arg='parms'/>
## <Returns>An integer.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A>, this function
## returns the number of pairwise non-isomorphic strongly regular graphs with parameters
## <A>parms</A> currently stored in this package.
## <Example>
## <![CDATA[
##gap> NrSRGs([36,15,6,6]);
##32548
##gap> NrSRGs([28,9,0,4]);
##0
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "NrSRGs" );

#############################################################################
##
#F OneSRG( <parms> )
##
## <#GAPDoc Label="OneSRG">
## <ManSection>
## <Func Name="OneSRG"
## Arg='parms'/>
## <Returns>A record or <K>fail</K>.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A>, this function
## returns one strongly regular graph with parameters <A>parms</A>. If there
## there is no strongly regular
## graph with parameters <A>parms</A> available, the function returns
## <K>fail</K>.
## <Example>
## <![CDATA[
##gap> OneSRG([16,9,4,6]);
##rec( adjacencies := [ [ 8, 9, 10, 11, 12, 13, 14, 15, 16 ] ],
## group := Group([ (6,7)(9,10)(12,13)(15,16), (5,6)(8,9)(11,12)(14,15), (2,5)
## (3,6)(4,7)(9,11)(10,14)(13,15), (1,2)(5,8)(6,9)(7,10) ]), isGraph := true,
## names := [ 1 .. 16 ], order := 16, representatives := [ 1 ],
## schreierVector := [ -1, 4, 3, 3, 3, 2, 1, 4, 4, 4, 3, 2, 1, 3, 2, 1 ] )
##gap> OneSRG([28,9,0,4]);
##fail
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "OneSRG" );

#############################################################################
##
#F AllSRGs( <parms> )
##
## <#GAPDoc Label="AllSRGs">
## <ManSection>
## <Func Name="AllSRGs"
## Arg='parms'/>
## <Returns>A list.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A>, this function
## returns a list of all pairwise non-isomorphic
## strongly regular graphs with parameters <A>parms</A> available in this package.
## <Example>
## <![CDATA[
##gap> AllSRGs([16,6,2,2]);
##[ rec( adjacencies := [ [ 2, 3, 4, 5, 6, 7 ] ],
## group := <permutation group with 6 generators>, isGraph := true,
## names := [ 1 .. 16 ], order := 16, representatives := [ 1 ],
## schreierVector := [ -1, 6, 4, 3, 5, 5, 5, 6, 6, 6, 4, 4, 4, 3, 3, 3 ] ),
## rec( adjacencies := [ [ 2, 3, 4, 5, 6, 7 ] ], group := Group([ (3,4)(5,6)
## (8,9)(11,14)(12,13)(15,16), (2,3)(4,5)(6,7)(9,11)(10,12)(14,15), (1,2)
## (5,8)(6,9)(7,10)(11,12)(13,14) ]), isGraph := true,
## names := [ 1 .. 16 ], order := 16, representatives := [ 1 ],
## schreierVector := [ -1, 3, 2, 1, 2, 1, 2, 3, 3, 3, 2, 2, 1, 1, 2, 1 ] )]
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "AllSRGs" );

#############################################################################
##
#F SRGIterator( <parms> )
##
## <#GAPDoc Label="SRGIterator">
## <ManSection>
## <Func Name="SRGIterator"
## Arg='parms'/>
## <Returns>An iterator.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A>, this function
## returns an iterator of all pairwise non-isomorphic
## strongly regular graph with parameters <A>parms</A> that
## are stored in this package.
## <Example>
## <![CDATA[
##gap> SRGIterator([16,6,2,2]);
##<iterator>
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "SRGIterator" );

#############################################################################
##
#F SmallFeasibleSRGParameterTuples( <v> )
##
## <#GAPDoc Label="SmallFeasibleSRGParameterTuples">
## <ManSection>
## <Func Name="SmallFeasibleSRGParameterTuples"
## Arg='v'/>
## <Returns>A list.</Returns>
##
## <Description>
## Given an integer <A>v</A>, this function returns a list of all feasible parameter tuples
## with at most <A>v</A> vertices, according to the list of Brouwer <Cite Key="B_2018"/>. The list
## contains parameter tuples with first parameter at most <Ref Var="AGT_Brouwer_Parameters_MAX"/>.
## <Example>
## <![CDATA[
##gap> SmallFeasibleSRGParameterTuples(16);
##[ [ 5, 2, 0, 1 ], [ 9, 4, 1, 2 ], [ 10, 3, 0, 1 ], [ 10, 6, 3, 4 ],
## [ 13, 6, 2, 3 ], [ 15, 6, 1, 3 ], [ 15, 8, 4, 4 ], [ 16, 5, 0, 2 ],
## [ 16, 10, 6, 6 ], [ 16, 6, 2, 2 ], [ 16, 9, 4, 6 ] ]
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "SmallFeasibleSRGParameterTuples" );

#############################################################################
##
#F IsEnumeratedSRGParameterTuple( [ <v>, <k>, <a>, ] )
##
## <#GAPDoc Label="IsEnumeratedSRGParameterTuple">
## <ManSection>
## <Func Name="IsEnumeratedSRGParameterTuple"
## Arg='parms'/>
## <Returns><K>true</K> or <K>false</K>.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A> with first
## parameter <A>v</A> at most <Ref Var="AGT_Brouwer_Parameters_MAX"/>, this
## function returns <K>true</K> if the
## strongly regular graphs with parameters <A>parms</A> have been enumerated,
## according to the list of Brouwer <Cite Key="B_2018"/>. Otherwise, this function returns
## <K>false</K>.
## <Example>
## <![CDATA[
##gap> IsEnumeratedSRGParameterTuple([37,18,8,9]);
##false
##gap> IsEnumeratedSRGParameterTuple([56,10,0,2]);
##true
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "IsEnumeratedSRGParameterTuple" );

#############################################################################
##
#F IsKnownSRGParameterTuple( [ <v>, <k>, <l>, <m> ] )
##
## <#GAPDoc Label="IsKnownSRGParameterTuple">
## <ManSection>
## <Func Name="IsKnownSRGParameterTuple"
## Arg='parms'/>
## <Returns><K>true</K> or <K>false</K>.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A> with first
## parameter <A>v</A> at most <Ref Var="AGT_Brouwer_Parameters_MAX"/>, this
## function returns <K>true</K> if it is known that there exists a strongly
## regular graph with parameters <A>parms</A>, according to the list of Brouwer <Cite Key="B_2018"/>.
## Otherwise, this function returns <K>false</K>.
## <Example>
## <![CDATA[
##gap> IsKnownSRGParameterTuple([64,28,12,12]);
##true
##gap> IsKnownSRGParameterTuple([64,30,18,10]);
##false
##gap> IsKnownSRGParameterTuple([65,32,15,16]);
##false
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "IsKnownSRGParameterTuple" );

#############################################################################
##
#F IsAllSRGsStored( [ <v>, <k>, <a>, ] )
##
## <#GAPDoc Label="IsAllSRGsStored">
## <ManSection>
## <Func Name="IsAllSRGsStored"
## Arg='parms'/>
## <Returns><K>true</K> or <K>false</K>.</Returns>
##
## <Description>
## Given feasible strongly regular graph parameters <A>parms</A> with first
## parameter <A>v</A> at most <Ref Var="AGT_Brouwer_Parameters_MAX"/>, this
## function returns <K>true</K> if all pairwise non-isomorphic
## strongly regular graphs with parameters <A>parms</A> are stored in the package.
## Otherwise, this function returns
## <K>false</K>.
## <Example>
## <![CDATA[
##gap> IsAllSRGsStored([37,18,8,9]);
##false
##gap> IsAllSRGsStored([36,15,6,6]);
##true
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "IsAllSRGsStored" );

#############################################################################
##
#F DisjointUnionOfCliques( <n1> , <n2>, ... )
##
## <#GAPDoc Label="DisjointUnionOfCliques">
## <ManSection>
## <Func Name="DisjointUnionOfCliques"
## Arg='n1, n2, ... '/>
## <Returns>A record.</Returns>
##
## <Description>
## Given positive integers <A>n1, n2,...</A>, this function returns the graph consisting of
## the disjoint union of cliques with orders <A>n1, n2,...</A>.
## <Example>
## <![CDATA[
##gap> DisjointUnionOfCliques(3,5,7);
##rec( adjacencies := [ [ 2, 3 ], [ 5, 6, 7, 8 ], [ 10, 11, 12, 13, 14, 15 ] ],
## autGroup := <permutation group with 12 generators>,
## group := <permutation group with 12 generators>, isGraph := true,
## isSimple := true, order := 15, representatives := [ 1, 4, 9 ],
## schreierVector := [ -1, 12, 11, -2, 10, 9, 8, 7, -3, 6, 5, 4, 3, 2, 1 ] )
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "DisjointUnionOfCliques" );

#############################################################################
##
#F CompleteMultipartiteGraph( <n1> , <n2>, ... )
##
## <#GAPDoc Label="CompleteMultipartiteGraph">
## <ManSection>
## <Func Name="CompleteMultipartiteGraph"
## Arg='n1, n2, ... '/>
## <Returns>A record.</Returns>
##
## <Description>
## Given positive integers <A>n1, n2,...</A>, this function returns the complete multipartite
## graph with parts of orders <A>n1, n2,...</A>.
## 
## Let <M>n_{1},n_{2},\dots,n_{t}</M> be positive integers. Then the <E>complete
## multipartite graph</E>, <M>K_{n_{1},n_{2},\dots,n_{t}}</M>, has vertex set that
## can be partitioned into <M>t</M> disjoint sets <M>X_{1},X_{2},\dots,X_{t}</M> of sizes <M>n_{1},n_{2},\dots,n_{t}</M>
## such that distinct vertices are adjacent if and only if they belong to different
## <M>X_{i}</M>.
## <Example>
## <![CDATA[
##gap> CompleteMultipartiteGraph(4,2,1);
##rec( adjacencies := [ [ 5, 6, 7 ], [ 1, 2, 3, 4, 7 ], [ 1, 2, 3, 4, 5, 6 ] ],
## autGroup := Group([ (5,6), (3,4), (2,3), (1,2) ]), group := Group([ (5,6),
## (3,4), (2,3), (1,2) ]), isGraph := true, isSimple := true, order := 7,
## representatives := [ 1, 5, 7 ],
## schreierVector := [ -1, 4, 3, 2, -2, 1, -3 ] )
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "CompleteMultipartiteGraph" );

#############################################################################
##
#F TriangularGraph( <n> )
##
## <#GAPDoc Label="TriangularGraph">
## <ManSection>
## <Func Name="TriangularGraph"
## Arg='n'/>
## <Returns>A record.</Returns>
##
## <Description>
## Given an integer <A>n</A>, where <M><A>n</A>\geq 3</M>, this function
## returns the triangular graph on <A>n</A> points.
## 
## Let <M>n</M> be an integer, where <M>n\geq 3</M>. The <E>triangular graph</E>
## , <M>T(n)</M>, has vertex set consisting of the subsets of <M>\{1,2,...,n\}</M>
## of size <M>2</M>, and two distinct vertices <M>A,B</M> are joined by an edge
## precisely when <M>|A\cap B|=1</M>.
## 
## The graph <M>T(n)</M> is strongly regular with parameters <M>({n \choose 2},2(n-2),n-2,4)</M>.
## For <M>n\not= 8</M>, <M>T(n)</M> is the unique strongly regular graph with its
## parameters. There are four pairwise non-isomomorphic strongly regular graphs that have the same
## parameters as <M>T(8)</M>, which are the triangular graph <M>T(8)</M> and the
## <E>Chang graphs</E> (see <Cite Key="C_1958"/> and <Cite Key="C_1959"/>).
##
## <Example>
## <![CDATA[
##gap> TriangularGraph(7);
##rec( adjacencies := [ [ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ] ],
## group := Group([ (1,7,12,16,19,21,6)(2,8,13,17,20,5,11)(3,9,14,18,4,10,15),
## (2,7)(3,8)(4,9)(5,10)(6,11) ]), isGraph := true, isSimple := true,
## names := [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 1, 6 ], [ 1, 7 ],
## [ 2, 3 ], [ 2, 4 ], [ 2, 5 ], [ 2, 6 ], [ 2, 7 ], [ 3, 4 ], [ 3, 5 ],
## [ 3, 6 ], [ 3, 7 ], [ 4, 5 ], [ 4, 6 ], [ 4, 7 ], [ 5, 6 ], [ 5, 7 ],
## [ 6, 7 ] ], order := 21, representatives := [ 1 ],
## schreierVector := [ -1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
## 1, 1, 1 ] )
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "TriangularGraph" );

#############################################################################
##
#F SquareLatticeGraph( <n> )
##
## <#GAPDoc Label="SquareLatticeGraph">
## <ManSection>
## <Func Name="SquareLatticeGraph"
## Arg='n'/>
## <Returns>A record.</Returns>
##
## <Description>
## Given an integer <A>n</A>, where <M><A>n</A>\geq 2</M>, this function
## returns the square lattice graph on <M>n^{2}</M> points.
## 
## Let <M>n</M> be an integer, where <M>n\geq 2</M>. The <E>square lattice
## graph</E>, <M>L_{2}(n)</M>, has vertex set <M>\{1,2,...,n\}\times\{1,2,...,n\}</M>, and two
## distinct vertices are joined by an edge precisely when they have the same
## value at one coordinate.
## 
## The graph <M>L_{2}(n)</M> is strongly regular with parameters <M>(n^{2},2(n-1),n-2,2)</M>.
## For <M>n\not= 4</M>, <M>L_{2}(n)</M> is the unique strongly regular graph with its
## parameters. There are two pairwise non-isomomorphic strongly regular graphs that have the same
## parameters as <M>L_{2}(4)</M>, which are the square lattice graph graph <M>L_{2}(4)</M> and the
## <E>Shrikhande graph</E> (see <Cite Key="S_1959b"/>).
## <Example>
## <![CDATA[
##gap> SquareLatticeGraph(6);
##rec( adjacencies := [ [ 2, 3, 4, 5, 6, 7, 13, 19, 25, 31 ] ],
## group := <permutation group with 5 generators>, isGraph := true,
## names := [ [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 1, 6 ],
## [ 2, 1 ], [ 2, 2 ], [ 2, 3 ], [ 2, 4 ], [ 2, 5 ], [ 2, 6 ], [ 3, 1 ],
## [ 3, 2 ], [ 3, 3 ], [ 3, 4 ], [ 3, 5 ], [ 3, 6 ], [ 4, 1 ], [ 4, 2 ],
## [ 4, 3 ], [ 4, 4 ], [ 4, 5 ], [ 4, 6 ], [ 5, 1 ], [ 5, 2 ], [ 5, 3 ],
## [ 5, 4 ], [ 5, 5 ], [ 5, 6 ], [ 6, 1 ], [ 6, 2 ], [ 6, 3 ], [ 6, 4 ],
## [ 6, 5 ], [ 6, 6 ] ], order := 36, representatives := [ 1 ],
## schreierVector := [ -1, 3, 3, 3, 3, 3, 1, 3, 3, 3, 3, 3, 1, 3, 3, 3, 3, 3,
## 1, 3, 3, 3, 3, 3, 1, 3, 3, 3, 3, 3, 1, 3, 3, 3, 3, 3 ] )
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "SquareLatticeGraph" );

#############################################################################
##
#F HoffmanSingletonGraph( )
##
## <#GAPDoc Label="HoffmanSingletonGraph">
## <ManSection>
## <Func Name="HoffmanSingletonGraph"
## Arg=''/>
## <Returns>A record.</Returns>
##
## <Description>
## This function returns the Hoffman-Singleton graph.
## 
## The <E>Hoffman-Singleton graph</E> is the unique strongly regular graph with
## parameters <M>(50,7,0,1)</M>. For more information on this graph, see <Cite Key="B_2018b"/>.
## <Example>
## <![CDATA[
##gap> gamma:=HoffmanSingletonGraph();;
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "HoffmanSingletonGraph" );

#############################################################################
##
#F HigmanSimsGraph( )
##
## <#GAPDoc Label="HigmanSimsGraph">
## <ManSection>
## <Func Name="HigmanSimsGraph"
## Arg=''/>
## <Returns>A record.</Returns>
##
## <Description>
## This function returns the Higman-Sims graph.
## 
## The <E>Higman-Sims graph</E> is the unique strongly regular graph with
## parameters <M>(100,22,0,6)</M>. For more information on this graph, see <Cite Key="B_2018b"/>.
## <Example>
## <![CDATA[
##gap> gamma:=HigmanSimsGraph();;
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "HigmanSimsGraph" );

#############################################################################
##
#F SimsGerwitzGraph( )
##
## <#GAPDoc Label="SimsGerwitzGraph">
## <ManSection>
## <Func Name="SimsGerwitzGraph"
## Arg=''/>
## <Returns>A record.</Returns>
##
## <Description>
## This function returns the Sims-Gerwitz graph.
## 
## The <E>Sims-Gerwitz graph</E> is the unique strongly regular graph with
## parameters <M>(56,10,0,2)</M>. For more information on this graph, see <Cite Key="B_2018b"/>.
## <Example>
## <![CDATA[
##gap> gamma:=SimsGerwitzGraph();;
## ]]>
## </Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "SimsGerwitzGraph" );

#############################################################################
##
#E

Quellcode-Bibliothek srglib.gd Sprache: unbekannt

[ 0.90Quellennavigators ]