def CremonaRichmondConfiguration():
r"""
Return the Cremona-Richmond configuration
The Cremona-Richmond configuration is a set system whose incidence graph
is equal to the
:meth:`~sage.graphs.graph_generators.GraphGenerators.TutteCoxeterGraph`. It
is a generalized quadrangle of parameters `(2,2)`.
For more information, see the
:wikipedia:`Cremona-Richmond_configuration`.
EXAMPLES::
sage: H = designs.CremonaRichmondConfiguration(); H
Incidence structure with 15 points and 15 blocks
sage: g = graphs.TutteCoxeterGraph()
sage: H.incidence_graph().is_isomorphic(g)
True
"""
from sage.graphs.generators.smallgraphs import TutteCoxeterGraph
from sage.combinat.designs.incidence_structures import IncidenceStructure
g = TutteCoxeterGraph()
H = IncidenceStructure([g.neighbors(v) for v in g.bipartite_sets()[0]])
H.relabel()
return H
def __init__(self,
v=0,
k=0,
t=0,
size=0,
points=[],
blocks=[],
low_bd=0,
method='',
creator='',
timestamp=''):
"""
EXAMPLES:
sage: C=CoveringDesign(5,4,3,4,range(5),[[0,1,2,3],[0,1,2,4],[0,1,3,4],[0,2,3,4]],4, 'Lexicographic Covering')
sage: print C
C(5,4,3) = 4
Method: Lexicographic Covering
0 1 2 3
0 1 2 4
0 1 3 4
0 2 3 4
"""
self.__v = v
self.__k = k
self.__t = t
self.__size = size
if low_bd > 0:
self.__low_bd = low_bd
else:
self.__low_bd = schonheim(v, k, t)
self.__method = method
self.__creator = creator
self.__timestamp = timestamp
self.__incidence_structure = IncidenceStructure(points, blocks)
def underlying_hypergraph(self):
r"""
Return the underlying hypergraph of cocircuits of the vector configuration.
Edges of the hypergraph correspond to zeros in a cocircuit.
OUTPUT:
A hypergraph
EXAMPLES::
sage: from cn_hyperarr.vector_classes import *
sage: vc = VectorConfiguration([[1,0,0],[0,1,0],[0,0,1],[1,1,0],[0,1,1],[1,1,1]])
sage: vc.underlying_hypergraph()
Incidence structure with 6 points and 7 blocks
For a set of three linearly dependent vectors in dimension three there
is just one cocicuit and thus one block::
sage: vc = VectorConfiguration([[1,0,0],[0,1,0],[2,-1,0]])
sage: vc.underlying_hypergraph()
Incidence structure with 3 points and 1 blocks
"""
coc = set([v[1] for v in self.three_dim_cocircuits()])
return IncidenceStructure(coc)
def Hadamard3Design(n):
r"""
Return the Hadamard 3-design with parameters `3-(n, \frac n 2, \frac n 4 - 1)`.
This is the unique extension of the Hadamard `2`-design (see
:meth:`HadamardDesign`). We implement the description from pp. 12 in
[CvL]_.
INPUT:
- ``n`` (integer) -- a multiple of 4 such that `n>4`.
EXAMPLES::
sage: designs.Hadamard3Design(12)
Incidence structure with 12 points and 22 blocks
We verify that any two blocks of the Hadamard `3`-design `3-(8, 4, 1)`
design meet in `0` or `2` points. More generally, it is true that any two
blocks of a Hadamard `3`-design meet in `0` or `\frac{n}{4}` points (for `n
> 4`).
::
sage: D = designs.Hadamard3Design(8)
sage: N = D.incidence_matrix()
sage: N.transpose()*N
[4 2 2 2 2 2 2 2 2 2 2 2 2 0]
[2 4 2 2 2 2 2 2 2 2 2 2 0 2]
[2 2 4 2 2 2 2 2 2 2 2 0 2 2]
[2 2 2 4 2 2 2 2 2 2 0 2 2 2]
[2 2 2 2 4 2 2 2 2 0 2 2 2 2]
[2 2 2 2 2 4 2 2 0 2 2 2 2 2]
[2 2 2 2 2 2 4 0 2 2 2 2 2 2]
[2 2 2 2 2 2 0 4 2 2 2 2 2 2]
[2 2 2 2 2 0 2 2 4 2 2 2 2 2]
[2 2 2 2 0 2 2 2 2 4 2 2 2 2]
[2 2 2 0 2 2 2 2 2 2 4 2 2 2]
[2 2 0 2 2 2 2 2 2 2 2 4 2 2]
[2 0 2 2 2 2 2 2 2 2 2 2 4 2]
[0 2 2 2 2 2 2 2 2 2 2 2 2 4]
REFERENCES:
.. [CvL] \P. Cameron, J. H. van Lint, Designs, graphs, codes and
their links, London Math. Soc., 1991.
"""
if n == 1 or n == 4:
raise ValueError("The Hadamard design with n = %s does not extend to a three design." % n)
from sage.combinat.matrices.hadamard_matrix import hadamard_matrix
from sage.matrix.constructor import matrix, block_matrix
H = hadamard_matrix(n) #assumed to be normalised.
H1 = H.matrix_from_columns(range(1, n))
J = matrix(ZZ, n, n-1, [1]*(n-1)*n)
A1 = (H1+J)/2
A2 = (J-H1)/2
A = block_matrix(1, 2, [A1, A2]) #the incidence matrix of the design.
return IncidenceStructure(incidence_matrix=A, name="HadamardThreeDesign")
def HadamardDesign(n):
"""
As described in Section 1, p. 10, in [CvL]_. The input n must have the
property that there is a Hadamard matrix of order `n+1` (and that a
construction of that Hadamard matrix has been implemented...).
EXAMPLES::
sage: designs.HadamardDesign(7)
Incidence structure with 7 points and 7 blocks
sage: print(designs.HadamardDesign(7))
Incidence structure with 7 points and 7 blocks
For example, the Hadamard 2-design with `n = 11` is a design whose parameters are 2-(11, 5, 2).
We verify that `NJ = 5J` for this design. ::
sage: D = designs.HadamardDesign(11); N = D.incidence_matrix()
sage: J = matrix(ZZ, 11, 11, [1]*11*11); N*J
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
[5 5 5 5 5 5 5 5 5 5 5]
REFERENCES:
- [CvL] P. Cameron, J. H. van Lint, Designs, graphs, codes and
their links, London Math. Soc., 1991.
"""
from sage.combinat.matrices.hadamard_matrix import hadamard_matrix
from sage.matrix.constructor import matrix
H = hadamard_matrix(n + 1) #assumed to be normalised.
H1 = H.matrix_from_columns(range(1, n + 1))
H2 = H1.matrix_from_rows(range(1, n + 1))
J = matrix(ZZ, n, n, [1] * n * n)
MS = J.parent()
A = MS((H2 + J) / 2) # convert -1's to 0's; coerce entries to ZZ
# A is the incidence matrix of the block design
return IncidenceStructure(incidence_matrix=A, name="HadamardDesign")
def CompleteUniform(self, n, k):
r"""
Return the complete `k`-uniform hypergraph on `n` points.
INPUT:
- ``k,n`` -- nonnegative integers with `k\leq n`
EXAMPLES::
sage: h = hypergraphs.CompleteUniform(5,2); h
Incidence structure with 5 points and 10 blocks
sage: len(h.packing())
2
"""
from sage.combinat.designs.incidence_structures import IncidenceStructure
from itertools import combinations
return IncidenceStructure(list(combinations(range(n), k)))
def UniformRandomUniform(self, n, k, m):
r"""
Return a uniformly sampled `k`-uniform hypergraph on `n` points with
`m` hyperedges.
- ``n`` -- number of nodes of the graph
- ``k`` -- uniformity
- ``m`` -- number of edges
EXAMPLES::
sage: H = hypergraphs.UniformRandomUniform(52, 3, 17)
sage: H
Incidence structure with 52 points and 17 blocks
sage: H.is_connected()
False
TESTS::
sage: hypergraphs.UniformRandomUniform(-52, 3, 17)
Traceback (most recent call last):
...
ValueError: number of vertices should be non-negative
sage: hypergraphs.UniformRandomUniform(52.9, 3, 17)
Traceback (most recent call last):
...
ValueError: number of vertices should be an integer
sage: hypergraphs.UniformRandomUniform(52, -3, 17)
Traceback (most recent call last):
...
ValueError: the uniformity should be non-negative
sage: hypergraphs.UniformRandomUniform(52, I, 17)
Traceback (most recent call last):
...
ValueError: the uniformity should be an integer
"""
from sage.rings.integer import Integer
from sage.combinat.subset import Subsets
from sage.misc.prandom import sample
# Construct the vertex set
if n < 0:
raise ValueError("number of vertices should be non-negative")
try:
nverts = Integer(n)
except TypeError:
raise ValueError("number of vertices should be an integer")
vertices = range(nverts)
# Construct the edge set
if k < 0:
raise ValueError("the uniformity should be non-negative")
try:
uniformity = Integer(k)
except TypeError:
raise ValueError("the uniformity should be an integer")
all_edges = Subsets(vertices, uniformity)
try:
edges = sample(all_edges, m)
except OverflowError:
raise OverflowError(
"binomial({}, {}) too large to be treated".format(n, k))
except ValueError:
raise ValueError(
"number of edges m must be between 0 and binomial({}, {})".
format(n, k))
from sage.combinat.designs.incidence_structures import IncidenceStructure
return IncidenceStructure(points=vertices, blocks=edges)
def T2starGeneralizedQuadrangleGraph(q, dual=False, hyperoval=None, field=None, check_hyperoval=True):
r"""
Return the collinearity graph of the generalized quadrangle `T_2^*(q)`, or of its dual
Let `q=2^k` and `\Theta=PG(3,q)`. `T_2^*(q)` is a generalized quadrangle [GQwiki]_
of order `(q-1,q+1)`, see 3.1.3 in [PT09]_. Fix a plane `\Pi \subset \Theta` and a
`hyperoval <http://en.wikipedia.org/wiki/Oval_(projective_plane)#Even_q>`__
`O \subset \Pi`. The points of `T_2^*(q):=T_2^*(O)` are the points of `\Theta`
outside `\Pi`, and the lines are the lines of `\Theta` outside `\Pi`
that meet `\Pi` in a point of `O`.
INPUT:
- ``q`` -- a power of two
- ``dual`` -- if ``False`` (default), return the graph of `T_2^*(O)`.
Otherwise return the graph of the dual `T_2^*(O)`.
- ``hyperoval`` -- a hyperoval (i.e. a complete 2-arc; a set of points in the plane
meeting every line in 0 or 2 points) in the plane of points with 0th coordinate
0 in `PG(3,q)` over the field ``field``. Each point of ``hyperoval`` must be a length 4
vector over ``field`` with 1st non-0 coordinate equal to 1. By default, ``hyperoval`` and
``field`` are not specified, and constructed on the fly. In particular, ``hyperoval``
we build is the classical one, i.e. a conic with the point of intersection of its
tangent lines.
- ``field`` -- an instance of a finite field of order `q`, must be provided
if ``hyperoval`` is provided.
- ``check_hyperoval`` -- (default: ``True``) if ``True``,
check ``hyperoval`` for correctness.
EXAMPLES:
using the built-in construction::
sage: g=graphs.T2starGeneralizedQuadrangleGraph(4); g
T2*(O,4); GQ(3, 5): Graph on 64 vertices
sage: g.is_strongly_regular(parameters=True)
(64, 18, 2, 6)
sage: g=graphs.T2starGeneralizedQuadrangleGraph(4,dual=True); g
T2*(O,4)*; GQ(5, 3): Graph on 96 vertices
sage: g.is_strongly_regular(parameters=True)
(96, 20, 4, 4)
supplying your own hyperoval::
sage: F=GF(4,'b')
sage: O=[vector(F,(0,0,0,1)),vector(F,(0,0,1,0))]+map(lambda x: vector(F, (0,1,x^2,x)),F)
sage: g=graphs.T2starGeneralizedQuadrangleGraph(4, hyperoval=O, field=F); g
T2*(O,4); GQ(3, 5): Graph on 64 vertices
sage: g.is_strongly_regular(parameters=True)
(64, 18, 2, 6)
TESTS::
sage: F=GF(4,'b') # repeating a point...
sage: O=[vector(F,(0,1,0,0)),vector(F,(0,0,1,0))]+map(lambda x: vector(F, (0,1,x^2,x)),F)
sage: graphs.T2starGeneralizedQuadrangleGraph(4, hyperoval=O, field=F)
Traceback (most recent call last):
...
RuntimeError: incorrect hyperoval size
sage: O=[vector(F,(0,1,1,0)),vector(F,(0,0,1,0))]+map(lambda x: vector(F, (0,1,x^2,x)),F)
sage: graphs.T2starGeneralizedQuadrangleGraph(4, hyperoval=O, field=F)
Traceback (most recent call last):
...
RuntimeError: incorrect hyperoval
"""
from sage.combinat.designs.incidence_structures import IncidenceStructure
from sage.combinat.designs.block_design import ProjectiveGeometryDesign as PG
from sage.modules.free_module_element import free_module_element as vector
p, k = is_prime_power(q,get_data=True)
if k==0 or p!=2:
raise ValueError('q must be a power of 2')
if field is None:
F = FiniteField(q, 'a')
else:
F = field
Theta = PG(3, 1, F, point_coordinates=1)
Pi = set(filter(lambda x: x[0]==F.zero(), Theta.ground_set()))
if hyperoval is None:
O = filter(lambda x: x[1]+x[2]*x[3]==0 or (x[1]==1 and x[2]==0 and x[3]==0), Pi)
O = set(O)
else:
map(lambda x: x.set_immutable(), hyperoval)
O = set(hyperoval)
if check_hyperoval:
if len(O) != q+2:
raise RuntimeError("incorrect hyperoval size")
for L in Theta.blocks():
if set(L).issubset(Pi):
if not len(O.intersection(L)) in [0,2]:
raise RuntimeError("incorrect hyperoval")
L = map(lambda z: filter(lambda y: not y in O, z),
filter(lambda x: len(O.intersection(x)) == 1, Theta.blocks()))
if dual:
G = IncidenceStructure(L).intersection_graph()
G.name('T2*(O,'+str(q)+')*; GQ'+str((q+1,q-1)))
else:
G = IncidenceStructure(L).dual().intersection_graph()
G.name('T2*(O,'+str(q)+'); GQ'+str((q-1,q+1)))
return G
def AhrensSzekeresGeneralizedQuadrangleGraph(q, dual=False):
r"""
Return the collinearity graph of the generalized quadrangle `AS(q)`, or of its dual
Let `q` be an odd prime power. `AS(q)` is a generalized quadrangle [GQwiki]_ of
order `(q-1,q+1)`, see 3.1.5 in [PT09]_. Its points are elements
of `F_q^3`, and lines are sets of size `q` of the form
* `\{ (\sigma, a, b) \mid \sigma\in F_q \}`
* `\{ (a, \sigma, b) \mid \sigma\in F_q \}`
* `\{ (c \sigma^2 - b \sigma + a, -2 c \sigma + b, \sigma) \mid \sigma\in F_q \}`,
where `a`, `b`, `c` are arbitrary elements of `F_q`.
INPUT:
- ``q`` -- a power of an odd prime number
- ``dual`` -- if ``False`` (default), return the collinearity graph of `AS(q)`.
Otherwise return the collinearity graph of the dual `AS(q)`.
EXAMPLES::
sage: g=graphs.AhrensSzekeresGeneralizedQuadrangleGraph(5); g
AS(5); GQ(4, 6): Graph on 125 vertices
sage: g.is_strongly_regular(parameters=True)
(125, 28, 3, 7)
sage: g=graphs.AhrensSzekeresGeneralizedQuadrangleGraph(5,dual=True); g
AS(5)*; GQ(6, 4): Graph on 175 vertices
sage: g.is_strongly_regular(parameters=True)
(175, 30, 5, 5)
REFERENCE:
.. [GQwiki] `Generalized quadrangle
<http://en.wikipedia.org/wiki/Generalized_quadrangle>`__
.. [PT09] S. Payne, J. A. Thas.
Finite generalized quadrangles.
European Mathematical Society,
2nd edition, 2009.
"""
from sage.combinat.designs.incidence_structures import IncidenceStructure
p, k = is_prime_power(q,get_data=True)
if k==0 or p==2:
raise ValueError('q must be an odd prime power')
F = FiniteField(q, 'a')
L = []
for a in F:
for b in F:
L.append(tuple(map(lambda s: (s, a, b), F)))
L.append(tuple(map(lambda s: (a, s, b), F)))
for c in F:
L.append(tuple(map(lambda s: (c*s**2 - b*s + a, -2*c*s + b, s), F)))
if dual:
G = IncidenceStructure(L).intersection_graph()
G.name('AS('+str(q)+')*; GQ'+str((q+1,q-1)))
else:
G = IncidenceStructure(L).dual().intersection_graph()
G.name('AS('+str(q)+'); GQ'+str((q-1,q+1)))
return G