Coverage for local/lib/python2.7/site-packages/sage/combinat/designs/incidence_structures.py : 77%

r""" 

Incidence structures (i.e. hypergraphs, i.e. set systems) 

An incidence structure is specified by a list of points, blocks, or an incidence 

matrix ([1]_, [2]_). :class:`IncidenceStructure` instances have the following methods: 

{METHODS_OF_IncidenceStructure} 

REFERENCES: 

.. [1] Block designs and incidence structures from wikipedia, 

:wikipedia:`Block_design` 

:wikipedia:`Incidence_structure` 

.. [2] \E. Assmus, J. Key, Designs and their codes, CUP, 1992. 

AUTHORS: 

- Peter Dobcsanyi and David Joyner (2007-2008) 

This is a significantly modified form of part of the module block_design.py 

(version 0.6) written by Peter Dobcsanyi peter@designtheory.org. 

- Vincent Delecroix (2014): major rewrite 

Methods 

------- 

""" 

#*************************************************************************** 

# Copyright (C) 2007 # 

# # 

# Peter Dobcsanyi and David Joyner # 

# <peter@designtheory.org> <wdjoyner@gmail.com> # 

# # 

# # 

# Distributed under the terms of the GNU General Public License (GPL) # 

# as published by the Free Software Foundation; either version 2 of # 

# the License, or (at your option) any later version. # 

# http://www.gnu.org/licenses/ # 

#*************************************************************************** 

from __future__ import print_function 

import six 

from six import itervalues 

from six.moves import range 

from sage.misc.cachefunc import cached_method 

from sage.rings.all import ZZ 

from sage.rings.integer import Integer 

from sage.misc.latex import latex 

from sage.sets.set import Set 

class IncidenceStructure(object): 

r""" 

A base class for incidence structures (i.e. hypergraphs, i.e. set systems) 

An incidence structure (i.e. hypergraph, i.e. set system) can be defined 

from a collection of blocks (i.e. sets, i.e. edges), optionally with an 

explicit ground set (i.e. point set, i.e. vertex set). Alternatively they 

can be defined from a binary incidence matrix. 

INPUT: 

- ``points`` -- (i.e. ground set, i.e. vertex set) the underlying set. If 

``points`` is an integer `v`, then the set is considered to be `\{0, ..., 

v-1\}`. 

.. NOTE:: 

The following syntax, where ``points`` is ommitted, automatically 

defines the ground set as the union of the blocks:: 

sage: H = IncidenceStructure([['a','b','c'],['c','d','e']]) 

sage: H.ground_set() 

['a', 'b', 'c', 'd', 'e'] 

- ``blocks`` -- (i.e. edges, i.e. sets) the blocks defining the incidence 

structure. Can be any iterable. 

- ``incidence_matrix`` -- a binary incidence matrix. Each column represents 

a set. 

- ``name`` (a string, such as "Fano plane"). 

- ``check`` -- whether to check the input 

- ``copy`` -- (use with caution) if set to ``False`` then ``blocks`` must be 

a list of lists of integers. The list will not be copied but will be 

modified in place (each block is sorted, and the whole list is 

sorted). Your ``blocks`` object will become the 

:class:`IncidenceStructure` instance's internal data. 

EXAMPLES: 

An incidence structure can be constructed by giving the number of points and 

the list of blocks:: 

sage: IncidenceStructure(7, [[0,1,2],[0,3,4],[0,5,6],[1,3,5],[1,4,6],[2,3,6],[2,4,5]]) 

Incidence structure with 7 points and 7 blocks 

Only providing the set of blocks is sufficient. In this case, the ground set 

is defined as the union of the blocks:: 

sage: IncidenceStructure([[1,2,3],[2,3,4]]) 

Incidence structure with 4 points and 2 blocks 

Or by its adjacency matrix (a `\{0,1\}`-matrix in which rows are indexed by 

points and columns by blocks):: 

sage: m = matrix([[0,1,0],[0,0,1],[1,0,1],[1,1,1]]) 

sage: IncidenceStructure(m) 

Incidence structure with 4 points and 3 blocks 

The points can be any (hashable) object:: 

sage: V = [(0,'a'),(0,'b'),(1,'a'),(1,'b')] 

sage: B = [(V[0],V[1],V[2]), (V[1],V[2]), (V[0],V[2])] 

sage: I = IncidenceStructure(V, B) 

sage: I.ground_set() 

[(0, 'a'), (0, 'b'), (1, 'a'), (1, 'b')] 

sage: I.blocks() 

[[(0, 'a'), (0, 'b'), (1, 'a')], [(0, 'a'), (1, 'a')], [(0, 'b'), (1, 'a')]] 

The order of the points and blocks does not matter as they are sorted on 

input (see :trac:`11333`):: 

sage: A = IncidenceStructure([0,1,2], [[0],[0,2]]) 

sage: B = IncidenceStructure([1,0,2], [[0],[2,0]]) 

sage: B == A 

True 

sage: C = BlockDesign(2, [[0], [1,0]]) 

sage: D = BlockDesign(2, [[0,1], [0]]) 

sage: C == D 

True 

If you care for speed, you can set ``copy`` to ``False``, but in that 

case, your input must be a list of lists and the ground set must be `{0, 

..., v-1}`:: 

sage: blocks = [[0,1],[2,0],[1,2]] # a list of lists of integers 

sage: I = IncidenceStructure(3, blocks, copy=False) 

sage: I._blocks is blocks 

True 

""" 

def __init__(self, points=None, blocks=None, incidence_matrix=None, 

name=None, check=True, copy=True): 

r""" 

TESTS:: 

sage: IncidenceStructure(3, [[4]]) 

Traceback (most recent call last): 

... 

ValueError: Block [4] is not contained in the point set 

sage: IncidenceStructure(3, [[0,1],[0,2]], check=True) 

Incidence structure with 3 points and 2 blocks 

sage: IncidenceStructure(2, [[0,1,2,3,4,5]], check=False) 

Incidence structure with 2 points and 1 blocks 

We avoid to convert to integers when the points are not (but compare 

equal to integers because of coercion):: 

sage: V = GF(5) 

sage: e0,e1,e2,e3,e4 = V 

sage: [e0,e1,e2,e3,e4] == list(range(5)) # coercion makes them equal 

True 

sage: blocks = [[e0,e1,e2],[e0,e1],[e2,e4]] 

sage: I = IncidenceStructure(V, blocks) 

sage: type(I.ground_set()[0]) 

<... 'sage.rings.finite_rings.integer_mod.IntegerMod_int'> 

sage: type(I.blocks()[0][0]) 

<... 'sage.rings.finite_rings.integer_mod.IntegerMod_int'> 

TESTS:: 

sage: IncidenceStructure([]) 

Incidence structure with 0 points and 0 blocks 

""" 

from sage.matrix.constructor import matrix 

from sage.structure.element import Matrix 

# Reformatting input 

if isinstance(points, Matrix): 

assert incidence_matrix is None, "'incidence_matrix' cannot be defined when 'points' is a matrix" 

assert blocks is None, "'blocks' cannot be defined when 'points' is a matrix" 

incidence_matrix = points 

points = blocks = None 

elif (points is not None and 

blocks is None): 

blocks = points 

points = set().union(*blocks) 

if points: 

assert incidence_matrix is None, "'incidence_matrix' cannot be defined when 'points' is defined" 

if incidence_matrix: 

M = matrix(incidence_matrix) 

v = M.nrows() 

self._points = list(range(v)) 

self._point_to_index = None 

self._blocks = sorted(M.nonzero_positions_in_column(i) for i in range(M.ncols())) 

else: 

if isinstance(points, (int,Integer)): 

self._points = list(range(points)) 

self._point_to_index = None 

else: 

self._points = sorted(points) 

if self._points == list(range(len(points))) and all(isinstance(x,(int,Integer)) for x in self._points): 

self._point_to_index = None 

else: 

self._point_to_index = {e:i for i,e in enumerate(self._points)} 

if check: 

for block in blocks: 

if any(x not in self._points for x in block): 

raise ValueError("Block {} is not contained in the point set".format(block)) 

if len(block) != len(set(block)): 

raise ValueError("Repeated element in block {}".format(block)) 

if self._point_to_index: 

# translate everything to integers between 0 and v-1 

blocks = [sorted(self._point_to_index[e] for e in block) for block in blocks] 

elif copy: 

# create a new list made of sorted blocks 

blocks = [sorted(block) for block in blocks] 

else: 

# sort the data but avoid copying it 

for b in blocks: 

b.sort() 

blocks.sort() 

self._blocks = blocks 

self._name = str(name) if name is not None else 'IncidenceStructure' 

self._classes = None 

self._canonical_label = None 

def __iter__(self): 

""" 

Iterator over the blocks. 

EXAMPLES:: 

sage: sts = designs.steiner_triple_system(9) 

sage: list(sts) 

[[0, 1, 5], [0, 2, 4], [0, 3, 6], [0, 7, 8], [1, 2, 3], [1, 4, 7], 

[1, 6, 8], [2, 5, 8], [2, 6, 7], [3, 4, 8], [3, 5, 7], [4, 5, 6]] 

sage: b = IncidenceStructure('ab', ['a','ab']) 

sage: it = iter(b) 

sage: next(it) 

['a'] 

sage: next(it) 

['a', 'b'] 

""" 

if self._point_to_index is None: 

for b in self._blocks: 

yield b[:] 

else: 

for b in self._blocks: 

yield [self._points[i] for i in b] 

def __repr__(self): 

""" 

A print method. 

EXAMPLES:: 

sage: BD = IncidenceStructure(7,[[0,1,2],[0,3,4],[0,5,6],[1,3,5],[1,4,6],[2,3,6],[2,4,5]]) 

sage: BD 

Incidence structure with 7 points and 7 blocks 

""" 

return 'Incidence structure with {} points and {} blocks'.format( 

self.num_points(), self.num_blocks()) 

__str__ = __repr__ 

def __eq__(self, other): 

""" 

Test whether the two incidence structures are equal. 

TESTS:: 

sage: blocks = [[0,1,2],[0,3,4],[0,5,6],[1,3,5],[1,4,6],[2,3,6],[2,4,5]] 

sage: BD1 = IncidenceStructure(7, blocks) 

sage: M = BD1.incidence_matrix() 

sage: BD2 = IncidenceStructure(incidence_matrix=M) 

sage: BD1 == BD2 

True 

sage: e1 = frozenset([0,1]) 

sage: e2 = frozenset([2]) 

sage: sorted([e1,e2]) == [e1,e2] 

True 

sage: sorted([e2,e1]) == [e2,e1] 

True 

sage: I1 = IncidenceStructure([e1,e2], [[e1],[e1,e2]]) 

sage: I2 = IncidenceStructure([e1,e2], [[e2,e1],[e1]]) 

sage: I3 = IncidenceStructure([e2,e1], [[e1,e2],[e1]]) 

sage: I1 == I2 and I2 == I1 and I1 == I3 and I3 == I1 and I2 == I3 and I3 == I2 

True 

""" 

# We are extra careful in this method since we cannot assume that a 

# total order is defined on the point set. 

if not isinstance(other, IncidenceStructure): 

return False 

if self._points == other._points: 

return self._blocks == other._blocks 

if (self.num_points() != other.num_points() or 

self.num_blocks() != other.num_blocks()): 

return False 

p_to_i = self._point_to_index if self._point_to_index else list(range(self.num_points())) 

if any(p not in p_to_i for p in other.ground_set()): 

return False 

other_blocks = sorted(sorted(p_to_i[p] for p in b) for b in other.blocks()) 

return self._blocks == other_blocks 

def __ne__(self, other): 

r""" 

Difference test. 

EXAMPLES:: 

sage: BD1 = IncidenceStructure(7, [[0,1,2],[0,3,4],[0,5,6],[1,3,5],[1,4,6],[2,3,6],[2,4,5]]) 

sage: M = BD1.incidence_matrix() 

sage: BD2 = IncidenceStructure(incidence_matrix=M) 

sage: BD1 != BD2 

False 

""" 

return not self == other 

def __contains__(self, block): 

r""" 

Tests if a block belongs to the incidence structure 

INPUT: 

- ``block`` -- a block. 

EXAMPLES:: 

sage: [1,2,3,4] in IncidenceStructure([[1,2,3,4]]) 

True 

sage: [1,2,4,3] in IncidenceStructure([[1,2,3,4]]) 

True 

sage: [1,2,"3",4] in IncidenceStructure([[1,2,3,4]]) 

False 

sage: [1,2,"3",4] in IncidenceStructure([[1,2,"3",4]]) 

True 

More complicated examples:: 

sage: str="I had a dream of a time when a 3-lines patch does not kill one hour" 

sage: sets = Subsets(str.split(), 4) 

sage: IS = IncidenceStructure(sets) # a complete 4-uniform hypergraph 

sage: ["I", "dream", "of", "one"] in IS 

True 

sage: ["does", "patch", "kill", "dream"] in IS 

True 

sage: ["Am", "I", "finally", "done ?"] in IS 

False 

sage: IS = designs.ProjectiveGeometryDesign(3, 1, GF(2), point_coordinates=False) 

sage: [3,8,7] in IS 

True 

sage: [3,8,9] in IS 

False 

""" 

try: 

iter(block) 

except TypeError: 

return False 

# Relabel to 0,...,n-1 if necessary 

if self._point_to_index is not None: 

try: 

block = [self._point_to_index[x] for x in block] 

except KeyError: 

return False 

return sorted(block) in self._blocks 

def canonical_label(self): 

r""" 

Return a canonical label for the incidence structure. 

A canonical label is relabeling of the points into integers 

`\{0,...,n-1\}` such that isomorphic incidence structures are 

relabelled to equal objects. 

EXAMPLES:: 

sage: fano1 = designs.balanced_incomplete_block_design(7,3) 

sage: fano2 = designs.projective_plane(2) 

sage: fano1 == fano2 

False 

sage: fano1.relabel(fano1.canonical_label()) 

sage: fano2.relabel(fano2.canonical_label()) 

sage: fano1 == fano2 

True 

""" 

if self._canonical_label is None: 

from sage.graphs.graph import Graph 

g = Graph() 

n = self.num_points() 

g.add_edges((i+n,x) for i,b in enumerate(self._blocks) for x in b) 

canonical_label = g.canonical_label([list(range(n)),list(range(n,n+self.num_blocks()))],certificate=True)[1] 

canonical_label = [canonical_label[x] for x in range(n)] 

self._canonical_label = canonical_label 

return dict(zip(self._points,self._canonical_label)) 

def is_isomorphic(self, other, certificate=False): 

r""" 

Return whether the two incidence structures are isomorphic. 

INPUT: 

- ``other`` -- an incidence structure. 

- ``certificate`` (boolean) -- whether to return an 

isomorphism from ``self`` to ``other`` instead of a boolean 

answer. 

EXAMPLES:: 

sage: fano1 = designs.balanced_incomplete_block_design(7,3) 

sage: fano2 = designs.projective_plane(2) 

sage: fano1.is_isomorphic(fano2) 

True 

sage: fano1.is_isomorphic(fano2,certificate=True) 

{0: 0, 1: 1, 2: 2, 3: 6, 4: 4, 5: 3, 6: 5} 

TESTS:: 

sage: IS = IncidenceStructure([["A",5,pi],["A",5,"Wouhou"],["A","Wouhou",(9,9)],[pi,12]]) 

sage: IS2 = IS.copy() 

sage: IS2.relabel(IS2.canonical_label()) 

sage: IS.is_isomorphic(IS2) 

True 

sage: canon = IS.is_isomorphic(IS2,certificate=True) 

sage: IS.relabel(canon) 

sage: IS==IS2 

True 

sage: IS2 = IncidenceStructure([[1,2]]) 

sage: IS2.is_isomorphic(IS) 

False 

sage: IS2.is_isomorphic(IS,certificate=True) 

{} 

Checking whether two :class:`IncidenceStructure` are isomorphic 

incidentally computes their canonical label (if necessary). Thus, 

subsequent calls to :meth:`is_isomorphic` will be faster:: 

sage: IS1 = designs.projective_plane(3) 

sage: IS2 = IS1.relabel(Permutations(IS1.ground_set()).random_element(),inplace=False) 

sage: IS2 = IncidenceStructure(IS2.blocks()) 

sage: IS1._canonical_label is None and IS2._canonical_label is None 

True 

sage: IS1.is_isomorphic(IS2) 

True 

sage: IS1._canonical_label is None or IS2._canonical_label is None 

False 

""" 

if (self.num_points() != other.num_points() or 

self.num_blocks() != other.num_blocks() or 

sorted(self.block_sizes()) != sorted(other.block_sizes())): 

return {} if certificate else False 

A_canon = self.canonical_label() 

B_canon = other.canonical_label() 

A = self.relabel(A_canon,inplace=False) 

B = other.relabel(B_canon,inplace=False) 

if A == B: 

if certificate: 

B_canon_rev = {y:x for x,y in six.iteritems(B_canon)} 

return {x:B_canon_rev[xint] for x,xint in six.iteritems(A_canon)} 

else: 

return True 

else: 

return {} if certificate else False 

def isomorphic_substructures_iterator(self, H2,induced=False): 

r""" 

Iterates over all copies of ``H2`` contained in ``self``. 

A hypergraph `H_1` contains an isomorphic copy of a hypergraph `H_2` if 

there exists an injection `f:V(H_2)\mapsto V(H_1)` such that for any set 

`S_2\in E(H_2)` the set `S_1=f(S2)` belongs to `E(H_1)`. 

It is an *induced* copy if no other set of `E(H_1)` is contained in 

`f(V(H_2))`, i.e. `|E(H_2)|=\{S:S\in E(H_1)\text{ and }f(V(H_2))\}`. 

This function lists all such injections. In particular, the number of 

copies of `H` in itself is equal to *the size of its automorphism 

group*. 

See :mod:`~sage.combinat.designs.subhypergraph_search` for more information. 

INPUT: 

- ``H2`` an :class:`IncidenceStructure` object. 

- ``induced`` (boolean) -- whether to require the copies to be 

induced. Set to ``False`` by default. 

EXAMPLES: 

How many distinct `C_5` in Petersen's graph ? :: 

sage: P = graphs.PetersenGraph() 

sage: C = graphs.CycleGraph(5) 

sage: IP = IncidenceStructure(P.edges(labels=False)) 

sage: IC = IncidenceStructure(C.edges(labels=False)) 

sage: sum(1 for _ in IP.isomorphic_substructures_iterator(IC)) 

120 

As the automorphism group of `C_5` has size 10, the number of distinct 

unlabelled copies is 12. Let us check that all functions returned 

correspond to an actual `C_5` subgraph:: 

sage: for f in IP.isomorphic_substructures_iterator(IC): 

....: assert all(P.has_edge(f[x],f[y]) for x,y in C.edges(labels=False)) 

The number of induced copies, in this case, is the same:: 

sage: sum(1 for _ in IP.isomorphic_substructures_iterator(IC,induced=True)) 

120 

They begin to differ if we make one vertex universal:: 

sage: P.add_edges([(0,x) for x in P], loops=False) 

sage: IP = IncidenceStructure(P.edges(labels=False)) 

sage: IC = IncidenceStructure(C.edges(labels=False)) 

sage: sum(1 for _ in IP.isomorphic_substructures_iterator(IC)) 

420 

sage: sum(1 for _ in IP.isomorphic_substructures_iterator(IC,induced=True)) 

60 

The number of copies of `H` in itself is the size of its automorphism 

group:: 

sage: H = designs.projective_plane(3) 

sage: sum(1 for _ in H.isomorphic_substructures_iterator(H)) 

5616 

sage: H.automorphism_group().cardinality() 

5616 

""" 

from sage.combinat.designs.subhypergraph_search import SubHypergraphSearch 

return SubHypergraphSearch(self,H2,induced=induced) 

def copy(self): 

r""" 

Return a copy of the incidence structure. 

EXAMPLES:: 

sage: IS = IncidenceStructure([[1,2,3,"e"]],name="Test") 

sage: IS 

Incidence structure with 4 points and 1 blocks 

sage: copy(IS) 

Incidence structure with 4 points and 1 blocks 

sage: [1, 2, 3, 'e'] in copy(IS) 

True 

sage: copy(IS)._name 

'Test' 

""" 

IS = IncidenceStructure(self._blocks, 

name=self._name, 

check=False) 

IS.relabel(dict(zip(range(self.num_points()),self._points))) 

IS._canonical_label = None if self._canonical_label is None else self._canonical_label[:] 

return IS 

__copy__ = copy 

def induced_substructure(self, points): 

r""" 

Return the substructure induced by a set of points. 

The substructure induced in `\mathcal H` by a set `X\subseteq V(\mathcal 

H)` of points is the incidence structure `\mathcal H_X` defined on `X` 

whose sets are all `S\in \mathcal H` such that `S\subseteq X`. 

INPUT: 

- ``points`` -- a set of points. 

.. NOTE:: 

This method goes over all sets of ``self`` before building a new 

:class:`IncidenceStructure` (which involves some relabelling and 

sorting). It probably should not be called in a performance-critical 

code. 

EXAMPLES: 

A Fano plane with one point removed:: 

sage: F = designs.steiner_triple_system(7) 

sage: F.induced_substructure([0..5]) 

Incidence structure with 6 points and 4 blocks 

TESTS:: 

sage: F.induced_substructure([0..50]) 

Traceback (most recent call last): 

... 

ValueError: 7 is not a point of the incidence structure 

sage: F.relabel(dict(enumerate("abcdefg"))) 

sage: F.induced_substructure("abc") 

Incidence structure with 3 points and ... 

sage: F.induced_substructure("Y") 

Traceback (most recent call last): 

... 

ValueError: 'Y' is not a point of the incidence structure 

""" 

# Checking the input 

if self._point_to_index is None: 

n = self.num_points() 

for x in points: 

x = int(x) 

if x < 0 or x >= n: 

raise ValueError("{} is not a point of the incidence structure".format(x)) 

int_points = points 

else: 

try: 

int_points = [self._point_to_index[x] for x in points] 

except KeyError as bad_pt: 

raise ValueError("{} is not a point of the incidence structure".format(bad_pt)) 

int_points = set(int_points) 

return IncidenceStructure(points, 

[[self._points[x] for x in S] 

for S in self._blocks 

if int_points.issuperset(S)]) 

def trace(self, points, min_size=1, multiset=True): 

r""" 

Return the trace of a set of points. 

Given an hypergraph `\mathcal H`, the *trace* of a set `X` of points in 

`\mathcal H` is the hypergraph whose blocks are all non-empty `S \cap X` 

where `S \in \mathcal H`. 

INPUT: 

- ``points`` -- a set of points. 

- ``min_size`` (integer; default 1) -- minimum size of the sets to 

keep. By default all empty sets are discarded, i.e. ``min_size=1``. 

- ``multiset`` (boolean; default ``True``) -- whether to keep multiple 

copies of the same set. 

.. NOTE:: 

This method goes over all sets of ``self`` before building a new 

:class:`IncidenceStructure` (which involves some relabelling and 

sorting). It probably should not be called in a performance-critical 

code. 

EXAMPLES: 

A Baer subplane of order 2 (i.e. a Fano plane) in a projective plane of order 4:: 

sage: P4 = designs.projective_plane(4) 

sage: F = designs.projective_plane(2) 

sage: for x in Subsets(P4.ground_set(),7): 

....: if P4.trace(x,min_size=2).is_isomorphic(F): 

....: break 

sage: subplane = P4.trace(x,min_size=2); subplane 

Incidence structure with 7 points and 7 blocks 

sage: subplane.is_isomorphic(F) 

True 

TESTS:: 

sage: F.trace([0..50]) 

Traceback (most recent call last): 

... 

ValueError: 7 is not a point of the incidence structure 

sage: F.relabel(dict(enumerate("abcdefg"))) 

sage: F.trace("abc") 

Incidence structure with 3 points and ... 

sage: F.trace("Y") 

Traceback (most recent call last): 

... 

ValueError: 'Y' is not a point of the incidence structure 

""" 

# Checking the input 

if self._point_to_index is None: 

n = self.num_points() 

int_points = frozenset(int(x) for x in points) 

for x in int_points: 

if x < 0 or x >= n: 

raise ValueError("{} is not a point of the incidence structure".format(x)) 

else: 

try: 

int_points = frozenset(self._point_to_index[x] for x in points) 

except KeyError as bad_pt: 

raise ValueError("{} is not a point of the incidence structure".format(bad_pt)) 

blocks = [int_points.intersection(S) for S in self._blocks] 

if min_size: 

blocks = [S for S in blocks if len(S)>=min_size] 

if not multiset: 

blocks = set(blocks) 

IS = IncidenceStructure(blocks) 

IS.relabel({i:self._points[i] for i in int_points}) 

return IS 

def ground_set(self): 

r""" 

Return the ground set (i.e the list of points). 

EXAMPLES:: 

sage: IncidenceStructure(3, [[0,1],[0,2]]).ground_set() 

[0, 1, 2] 

""" 

return self._points[:] 

def num_points(self): 

r""" 

Return the size of the ground set. 

EXAMPLES:: 

sage: designs.DesarguesianProjectivePlaneDesign(2).num_points() 

7 

sage: B = IncidenceStructure(4, [[0,1],[0,2],[0,3],[1,2], [1,2,3]]) 

sage: B.num_points() 

4 

""" 

return len(self._points) 

def num_blocks(self): 

r""" 

Return the number of blocks. 

EXAMPLES:: 

sage: designs.DesarguesianProjectivePlaneDesign(2).num_blocks() 

7 

sage: B = IncidenceStructure(4, [[0,1],[0,2],[0,3],[1,2], [1,2,3]]) 

sage: B.num_blocks() 

5 

""" 

return len(self._blocks) 

def blocks(self): 

""" 

Return the list of blocks. 

EXAMPLES:: 

sage: BD = IncidenceStructure(7,[[0,1,2],[0,3,4],[0,5,6],[1,3,5],[1,4,6],[2,3,6],[2,4,5]]) 

sage: BD.blocks() 

[[0, 1, 2], [0, 3, 4], [0, 5, 6], [1, 3, 5], [1, 4, 6], [2, 3, 6], [2, 4, 5]] 

""" 

if self._point_to_index is None: 

return [b[:] for b in self._blocks] 

else: 

return [[self._points[i] for i in b] for b in self._blocks]