Ticket #1323: trac_1323-subspaces.patch

sage/combinat/designs/block_design.py

@@ -41 +41 @@
 
 import types
 from sage.matrix.matrix_space import MatrixSpace
+from sage.modules.free_module import VectorSpace
 from sage.rings.integer_ring import ZZ
 from sage.rings.arith import binomial, integer_floor
 from sage.rings.finite_field import FiniteField
@@ -48 +49 @@
 
 ###  utility functions  -------------------------------------------------------
 
-def subspaces_of_vs(F,n,k):
-    """
-    Computes the subsppaces of F^n of dimension k (k<=n),
-    if F is a finite field.
-
-    EXAMPLES:
-        sage: F = GF(2); n = 2; k = 1
-        sage: from sage.combinat.designs.block_design import subspaces_of_vs
-        sage: subspaces_of_vs(F,n,k)
-        [Vector space of degree 2 and dimension 1 over Finite Field of size 2
-        Basis matrix:
-        [0 1],
-         Vector space of degree 2 and dimension 1 over Finite Field of size 2
-        Basis matrix:
-        [1 0],
-         Vector space of degree 2 and dimension 1 over Finite Field of size 2
-        Basis matrix:
-        [1 1]]
-
-    """
-    from sage.interfaces.gap import gap, GapElement
-    from sage.interfaces.gap import gfq_gap_to_sage
-    q = F.order()
-    V = gap("GaloisField(%s)^%s"%(q,n))
-    S = V.Subspaces(k).AsSet()
-    MS = MatrixSpace(F,k,n)
-    L = []
-    for s in S:
-        B = s.Basis()
-        rows = []
-        for b in B:
-            r = [gfq_gap_to_sage(b[i],F) for i in range(1,n+1)]
-            rows.append(r)
-        M = MS(rows)
-        L.append(M.row_space())
-    return L
-    
 def tdesign_params(t, v, k, L):
     """
     Return the design's parameters: (t, v, b, r , k, L).
@@ -124 +88 @@
 
     """
     q = F.order()
-    from sage.combinat.designs.block_design import subspaces_of_vs
     from sage.interfaces.gap import gap, GapElement
     from sage.sets.set import Set
     if method == None:
-        points = subspaces_of_vs(F,n+1,1)
-        flats = subspaces_of_vs(F,n+1,d+1)
+        V = VectorSpace(F, n+1)
+        points = list(V.subspaces(1))
+        flats = list(V.subspaces(d+1))
         blcks = []
         for p in points:
             b = []

sage/modules/free_module.py

@@ -2720 +2720 @@
         """
         return self.submodule(gens, check=check, already_echelonized=already_echelonized)
     
+    def subspaces(self, dim):
+        """
+        Iterate over all subspaces of dimension dim.
+        
+        INPUT:
+            dim -- int, dimension of subspaces to be generated
+        
+        EXAMPLE:
+            sage: V = VectorSpace(GF(3), 5)
+            sage: len(list(V.subspaces(0)))
+            1
+            sage: len(list(V.subspaces(1)))
+            121
+            sage: len(list(V.subspaces(2)))
+            1210
+            sage: len(list(V.subspaces(3)))
+            1210
+            sage: len(list(V.subspaces(4)))
+            121
+            sage: len(list(V.subspaces(5)))
+            1
+        
+            sage: V = VectorSpace(GF(3), 5)
+            sage: V = V.subspace([V([1,1,0,0,0]),V([0,0,1,1,0])])
+            sage: list(V.subspaces(1))
+            [Vector space of degree 5 and dimension 1 over Finite Field of size 3
+            Basis matrix:
+            [1 1 0 0 0],
+             Vector space of degree 5 and dimension 1 over Finite Field of size 3
+            Basis matrix:
+            [1 1 1 1 0],
+             Vector space of degree 5 and dimension 1 over Finite Field of size 3
+            Basis matrix:
+            [1 1 2 2 0],
+             Vector space of degree 5 and dimension 1 over Finite Field of size 3
+            Basis matrix:
+            [0 0 1 1 0]]
+
+        """
+        if not self.base_ring().is_finite():
+            raise RuntimeError("Base ring must be finite.")
+        # First, we select which columns will be pivots:
+        from sage.combinat.subset import Subsets
+        BASE = self.basis_matrix()
+        for pivots in Subsets(range(self.dimension()), dim):
+            MAT = sage.matrix.matrix_space.MatrixSpace(self.base_ring(), dim,
+                self.dimension(), sparse = self.is_sparse())()
+            free_positions = []
+            for i in range(dim):
+                MAT[i, pivots[i]] = 1
+                for j in range(pivots[i]+1,self.dimension()):
+                    if j not in pivots:
+                        free_positions.append((i,j))
+            # Next, we fill in those entries that are not
+            # determined by the echelon form alone:
+            num_free_pos = len(free_positions)
+            ENTS = VectorSpace(self.base_ring(), num_free_pos)
+            for v in ENTS:
+                for k in range(num_free_pos):
+                    MAT[free_positions[k]] = v[k]
+                # Finally, we have to multiply by the basis matrix
+                # to take corresponding linear combinations of the basis
+                yield self.subspace((MAT*BASE).rows())
+    
     def subspace_with_basis(self, gens, check=True, already_echelonized=False):
         """
         Same as \code{self.submodule_with_basis(...)}.