passagemath-modules 10.5.32__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/matrix/matrix_sparse.pyx

@@ -17,7 +17,6 @@ from cysignals.signals cimport sig_check
 cimport sage.matrix.matrix as matrix
 cimport sage.matrix.matrix0 as matrix0
 from sage.categories.rings import Rings
-from sage.calculus.functional import derivative
 from sage.structure.element cimport Element, Vector
 from sage.structure.richcmp cimport richcmp_item, rich_to_bool
 
@@ -937,18 +936,18 @@ cdef class Matrix_sparse(matrix.Matrix):
 
         cdef Py_ssize_t nrows, ncols, k, i, j
 
-        ncols = PyList_GET_SIZE(columns)
-        nrows = PyList_GET_SIZE(rows)
+        ncols = len(columns)
+        nrows = len(rows)
         cdef Matrix_sparse A = self.new_matrix(nrows=nrows, ncols=ncols)
 
         tmp = [el for el in columns if 0 <= el < self._ncols]
         columns = tmp
-        if ncols != PyList_GET_SIZE(columns):
+        if ncols != len(columns):
             raise IndexError("column index out of range")
 
         tmp = [el for el in rows if 0 <= el < self._nrows]
         rows = tmp
-        if nrows != PyList_GET_SIZE(rows):
+        if nrows != len(rows):
             raise IndexError("row index out of range")
 
         row_map = {}
@@ -1151,7 +1150,7 @@ cdef class Matrix_sparse(matrix.Matrix):
             sage: (v * m).parent() is m.row(0).parent()
             True
             """
-        cdef int i, j
+        cdef Py_ssize_t i, j
         if self._nrows != v._degree:
             raise ArithmeticError("number of rows of matrix must equal degree of vector")
         parent = self.row_ambient_module(base_ring=None, sparse=v.is_sparse_c())
@@ -1204,7 +1203,7 @@ cdef class Matrix_sparse(matrix.Matrix):
             sage: M*w
             (x*y)
         """
-        cdef int i, j
+        cdef Py_ssize_t i, j
         if self._ncols != v._degree:
             raise ArithmeticError("number of columns of matrix must equal degree of vector")
         parent = self.column_ambient_module(base_ring=None, sparse=v.is_sparse_c())

sage/matrix/matrix_window.pyx

@@ -67,8 +67,8 @@ cdef class MatrixWindow:
         a = self._matrix.new_matrix(nrows, ncols)
         return self.new_matrix_window(a, 0, 0, nrows, ncols)
 
-    def __repr__(self):
-        return "Matrix window of size %s x %s at (%s,%s):\n%s"%(
+    def __repr__(self) -> str:
+        return "Matrix window of size %s x %s at (%s,%s):\n%s" % (
             self._nrows, self._ncols, self._row, self._col, self._matrix)
 
     ############################

sage/matrix/operation_table.py

@@ -15,8 +15,6 @@ This module implements general operation tables, which are very matrix-like.
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from copy import copy
-
 from sage.structure.sage_object import SageObject
 from sage.matrix.constructor import Matrix
 

sage/matrix/special.py

@@ -3013,6 +3013,10 @@ def random_unimodular_matrix(parent, upper_bound=None, max_tries=100):
         sage: y = polygen(ZZ, 'y')
         sage: K = NumberField(y^2 - 2*y - 2, 'y')
         sage: C = random_matrix(K, 3, algorithm='unimodular')
+        sage: C  # random
+        [      -1/7*y + 47/35       3/5*y - 127/70 -2917/70*y + 4419/70]
+        [                   1          1/2*y - 1/2     -104/3*y + 211/6]
+        [         1/3*y - 1/3                y - 1      -35/6*y - 149/6]
         sage: det(C)
         1
         sage: C.base_ring() is K
@@ -3130,7 +3134,7 @@ def random_diagonalizable_matrix(parent, eigenvalues=None, dimensions=None):
         sage: M = random_matrix(K, 3, 3, algorithm="diagonalizable")
         sage: M.parent()
         Full MatrixSpace of 3 by 3 dense matrices over Finite Field of size 3
-        sage: M.is_diagonalizable()
+        sage: M.is_diagonalizable()                                                     # needs sage.libs.pari
         True
         sage: M  # random
         [0 0 1]

sage/matrix/strassen.pyx

@@ -806,7 +806,7 @@ def test(n, m, R, c=2):
 
 #         TODO -- the doctests below are currently not
 #         tested/enabled/working -- enable them when linear algebra
-#         restructing gets going.
+#         restructuring gets going.
 
 #         sage: dim1 = 64; dim2 = 83; dim3 = 101
 #         sage: R = MatrixSpace(QQ, dim1, dim2)

sage/matroids/chow_ring.py

@@ -188,25 +188,25 @@ class ChowRing(QuotientRing_generic):
 
             sage: ch = matroids.Uniform(3, 6).chow_ring(QQ, True, 'fy')
             sage: ch.basis()
-            Family (1, B1, B1*B012345, B0, B0*B012345, B01, B01^2, B2,
-            B2*B012345, B02, B02^2, B12, B12^2, B3, B3*B012345, B03, B03^2,
-            B13, B13^2, B23, B23^2, B4, B4*B012345, B04, B04^2, B14, B14^2,
-            B24, B24^2, B34, B34^2, B5, B5*B012345, B05, B05^2, B15, B15^2,
-            B25, B25^2, B35, B35^2, B45, B45^2, B012345, B012345^2, B012345^3)
+            Family (1, B0, B0*B012345, B1, B1*B012345, B01, B01^2, B2,
+             B2*B012345, B12, B12^2, B02, B02^2, B3, B3*B012345, B23, B23^2,
+             B13, B13^2, B03, B03^2, B4, B4*B012345, B34, B34^2, B24, B24^2,
+             B14, B14^2, B04, B04^2, B5, B5*B012345, B45, B45^2, B35, B35^2,
+             B25, B25^2, B15, B15^2, B05, B05^2, B012345, B012345^2, B012345^3)
             sage: set(ch.defining_ideal().normal_basis()) == set(ch.basis())
             True
             sage: ch = matroids.catalog.Fano().chow_ring(QQ, False)
             sage: ch.basis()
-            Family (1, Abcd, Aace, Aabf, Adef, Aadg, Abeg, Acfg, Aabcdefg,
-            Aabcdefg^2)
+            Family (1, Abcd, Aace, Adef, Aabf, Acfg, Abeg, Aadg, Aabcdefg,
+             Aabcdefg^2)
             sage: set(ch.defining_ideal().normal_basis()) == set(ch.basis())
             True
             sage: ch = matroids.Wheel(3).chow_ring(QQ, True, 'atom-free')
             sage: ch.basis()
-            Family (1, A0, A0*A012345, A2, A2*A012345, A3, A3*A012345, A23,
-            A23^2, A1, A1*A012345, A013, A013^2, A4, A4*A012345, A04, A04^2,
-            A124, A124^2, A5, A5*A012345, A025, A025^2, A15, A15^2, A345,
-            A345^2, A012345, A012345^2, A012345^3)
+            Family (1, A0, A0*A012345, A1, A1*A012345, A2, A2*A012345, A3,
+             A3*A012345, A23, A23^2, A013, A013^2, A4, A4*A012345, A124, A124^2,
+             A04, A04^2, A5, A5*A012345, A345, A345^2, A15, A15^2, A025, A025^2,
+             A012345, A012345^2, A012345^3)
             sage: set(ch.defining_ideal().normal_basis()) == set(ch.basis())
             True
         """
@@ -247,12 +247,14 @@ class ChowRing(QuotientRing_generic):
             ....:     basis_deg[deg].append(b)
             ....:
             sage: basis_deg
-            {0: [1], 1: [A02, A12, A01, A012, A03, A13, A013, A23, A023,
-                A123, A04, A14, A014, A24, A024, A124, A34, A034, A134, A234,
-                A01234], 2: [A02*A01234, A12*A01234, A01*A01234, A012^2,
-                A03*A01234, A13*A01234, A013^2, A23*A01234, A023^2, A123^2,
-                A04*A01234, A14*A01234, A014^2, A24*A01234, A024^2, A124^2,
-                A34*A01234, A034^2, A134^2, A234^2, A01234^2], 3: [A01234^3]}
+            {0: [1],
+             1: [A01, A12, A02, A012, A23, A13, A123, A03, A013, A023, A34, A24,
+                 A234, A14, A124, A134, A04, A014, A024, A034, A01234],
+             2: [A01*A01234, A12*A01234, A02*A01234, A012^2, A23*A01234,
+                 A13*A01234, A123^2, A03*A01234, A013^2, A023^2, A34*A01234,
+                 A24*A01234, A234^2, A14*A01234, A124^2, A134^2, A04*A01234,
+                 A014^2, A024^2, A034^2, A01234^2],
+             3: [A01234^3]}
             sage: g_eq_maps = {}
             sage: lefschetz_el = ch.lefschetz_element(); lefschetz_el
             -2*A01 - 2*A02 - 2*A03 - 2*A04 - 2*A12 - 2*A13 - 2*A14 - 2*A23
@@ -264,37 +266,38 @@ class ChowRing(QuotientRing_generic):
             ....:     g_eq_maps[deg].extend([i*lefschetz_el for i in basis_deg[deg]])
             ....:
             sage: g_eq_maps
-            {0: [-2*A01 - 2*A02 - 2*A03 - 2*A04 - 2*A12 - 2*A13 - 2*A14
-                - 2*A23 - 2*A24 - 2*A34 - 6*A012 - 6*A013 - 6*A014 - 6*A023
-                - 6*A024 - 6*A034 - 6*A123 - 6*A124 - 6*A134 - 6*A234
-                - 20*A01234], 1: [2*A012^2 + 2*A023^2 + 2*A024^2
-                - 10*A02*A01234 + 2*A01234^2, 2*A012^2 + 2*A123^2 + 2*A124^2
-                - 10*A12*A01234 + 2*A01234^2, 2*A012^2 + 2*A013^2 + 2*A014^2
-                - 10*A01*A01234 + 2*A01234^2, -6*A012^2 + 2*A01*A01234
-                + 2*A02*A01234 + 2*A12*A01234, 2*A013^2 + 2*A023^2 + 2*A034^2
-                - 10*A03*A01234 + 2*A01234^2, 2*A013^2 + 2*A123^2 + 2*A134^2
-                - 10*A13*A01234 + 2*A01234^2, -6*A013^2 + 2*A01*A01234
-                + 2*A03*A01234 + 2*A13*A01234, 2*A023^2 + 2*A123^2 + 2*A234^2
-                - 10*A23*A01234 + 2*A01234^2, -6*A023^2 + 2*A02*A01234
-                + 2*A03*A01234 + 2*A23*A01234, -6*A123^2 + 2*A12*A01234
-                + 2*A13*A01234 + 2*A23*A01234, 2*A014^2 + 2*A024^2 + 2*A034^2
-                - 10*A04*A01234 + 2*A01234^2, 2*A014^2 + 2*A124^2 + 2*A134^2
-                - 10*A14*A01234 + 2*A01234^2, -6*A014^2 + 2*A01*A01234
-                + 2*A04*A01234 + 2*A14*A01234, 2*A024^2 + 2*A124^2 + 2*A234^2
-                - 10*A24*A01234 + 2*A01234^2, -6*A024^2 + 2*A02*A01234
-                + 2*A04*A01234 + 2*A24*A01234, -6*A124^2 + 2*A12*A01234
-                + 2*A14*A01234 + 2*A24*A01234, 2*A034^2 + 2*A134^2 + 2*A234^2
-                - 10*A34*A01234 + 2*A01234^2, -6*A034^2 + 2*A03*A01234
-                + 2*A04*A01234 + 2*A34*A01234, -6*A134^2 + 2*A13*A01234
-                + 2*A14*A01234 + 2*A34*A01234, -6*A234^2 + 2*A23*A01234
-                + 2*A24*A01234 + 2*A34*A01234, -2*A01*A01234 - 2*A02*A01234
-                - 2*A03*A01234 - 2*A04*A01234 - 2*A12*A01234 - 2*A13*A01234
-                - 2*A14*A01234 - 2*A23*A01234 - 2*A24*A01234 - 2*A34*A01234
-                - 20*A01234^2], 2: [2*A01234^3, 2*A01234^3, 2*A01234^3,
-                6*A01234^3, 2*A01234^3, 2*A01234^3, 6*A01234^3, 2*A01234^3,
-                6*A01234^3, 6*A01234^3, 2*A01234^3, 2*A01234^3, 6*A01234^3,
-                2*A01234^3, 6*A01234^3, 6*A01234^3, 2*A01234^3, 6*A01234^3,
-                6*A01234^3, 6*A01234^3, -20*A01234^3], 3: [0]}
+            {0: [-2*A01 - 2*A02 - 2*A03 - 2*A04 - 2*A12 - 2*A13 - 2*A14 - 2*A23
+                 - 2*A24 - 2*A34 - 6*A012 - 6*A013 - 6*A014 - 6*A023 - 6*A024
+                 - 6*A034 - 6*A123 - 6*A124 - 6*A134 - 6*A234 - 20*A01234],
+             1: [2*A012^2 + 2*A013^2 + 2*A014^2 - 10*A01*A01234 + 2*A01234^2,
+                 2*A012^2 + 2*A123^2 + 2*A124^2 - 10*A12*A01234 + 2*A01234^2,
+                 2*A012^2 + 2*A023^2 + 2*A024^2 - 10*A02*A01234 + 2*A01234^2,
+                 -6*A012^2 + 2*A01*A01234 + 2*A02*A01234 + 2*A12*A01234,
+                 2*A023^2 + 2*A123^2 + 2*A234^2 - 10*A23*A01234 + 2*A01234^2,
+                 2*A013^2 + 2*A123^2 + 2*A134^2 - 10*A13*A01234 + 2*A01234^2,
+                 -6*A123^2 + 2*A12*A01234 + 2*A13*A01234 + 2*A23*A01234,
+                 2*A013^2 + 2*A023^2 + 2*A034^2 - 10*A03*A01234 + 2*A01234^2,
+                 -6*A013^2 + 2*A01*A01234 + 2*A03*A01234 + 2*A13*A01234,
+                 -6*A023^2 + 2*A02*A01234 + 2*A03*A01234 + 2*A23*A01234,
+                 2*A034^2 + 2*A134^2 + 2*A234^2 - 10*A34*A01234 + 2*A01234^2,
+                 2*A024^2 + 2*A124^2 + 2*A234^2 - 10*A24*A01234 + 2*A01234^2,
+                 -6*A234^2 + 2*A23*A01234 + 2*A24*A01234 + 2*A34*A01234,
+                 2*A014^2 + 2*A124^2 + 2*A134^2 - 10*A14*A01234 + 2*A01234^2,
+                 -6*A124^2 + 2*A12*A01234 + 2*A14*A01234 + 2*A24*A01234,
+                 -6*A134^2 + 2*A13*A01234 + 2*A14*A01234 + 2*A34*A01234,
+                 2*A014^2 + 2*A024^2 + 2*A034^2 - 10*A04*A01234 + 2*A01234^2,
+                 -6*A014^2 + 2*A01*A01234 + 2*A04*A01234 + 2*A14*A01234,
+                 -6*A024^2 + 2*A02*A01234 + 2*A04*A01234 + 2*A24*A01234,
+                 -6*A034^2 + 2*A03*A01234 + 2*A04*A01234 + 2*A34*A01234,
+                 -2*A01*A01234 - 2*A02*A01234 - 2*A03*A01234 - 2*A04*A01234
+                 - 2*A12*A01234 - 2*A13*A01234 - 2*A14*A01234 - 2*A23*A01234
+                 - 2*A24*A01234 - 2*A34*A01234 - 20*A01234^2],
+             2: [2*A01234^3, 2*A01234^3, 2*A01234^3, 6*A01234^3, 2*A01234^3,
+                 2*A01234^3, 6*A01234^3, 2*A01234^3, 6*A01234^3, 6*A01234^3,
+                 2*A01234^3, 2*A01234^3, 6*A01234^3, 2*A01234^3, 6*A01234^3,
+                 6*A01234^3, 2*A01234^3, 6*A01234^3, 6*A01234^3, 6*A01234^3,
+                 -20*A01234^3],
+             3: [0]}
         """
         w = sum(len(F) * (len(self.matroid().groundset()) - len(F)) * gen
                 for F, gen in self.defining_ideal().flats_to_generator_dict().items())
@@ -338,7 +341,7 @@ class ChowRing(QuotientRing_generic):
                 sage: v = ch.an_element(); v
                 -A01 - A02 - A03 - A04 - A05 - A012345
                 sage: v.to_vector()
-                (0, -1, -1, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0)
+                (0, -1, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, -1, -1, 0)
             """
             P = self.parent()
             B = P.basis()
@@ -379,20 +382,20 @@ class ChowRing(QuotientRing_generic):
                 ....:     print(b, b.degree())
                 1 0
                 A01 1
-                A02 1
                 A12 1
-                A03 1
-                A13 1
+                A02 1
                 A23 1
-                A04 1
-                A14 1
-                A24 1
+                A13 1
+                A03 1
                 A34 1
-                A05 1
-                A15 1
-                A25 1
-                A35 1
+                A24 1
+                A14 1
+                A04 1
                 A45 1
+                A35 1
+                A25 1
+                A15 1
+                A05 1
                 A012345 1
                 A012345^2 2
                 sage: v = sum(ch.basis())
@@ -428,18 +431,18 @@ class ChowRing(QuotientRing_generic):
                 Bace^2 2
                 Bf 1
                 Bf*Babcdefg 2
-                Babf 1
-                Babf^2 2
                 Bdef 1
                 Bdef^2 2
+                Babf 1
+                Babf^2 2
                 Bg 1
                 Bg*Babcdefg 2
-                Badg 1
-                Badg^2 2
-                Bbeg 1
-                Bbeg^2 2
                 Bcfg 1
                 Bcfg^2 2
+                Bbeg 1
+                Bbeg^2 2
+                Badg 1
+                Badg^2 2
                 Babcdefg 1
                 Babcdefg^2 2
                 Babcdefg^3 3

sage/matroids/chow_ring_ideal.py

@@ -17,12 +17,13 @@ AUTHORS:
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from sage.rings.polynomial.multi_polynomial_ideal import MPolynomialIdeal
+from itertools import product
+
+from sage.combinat.posets.posets import Poset
 from sage.matroids.utilities import cmp_elements_key
-from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+from sage.rings.polynomial.multi_polynomial_ideal import MPolynomialIdeal
 from sage.rings.polynomial.multi_polynomial_sequence import PolynomialSequence
-from sage.combinat.posets.posets import Poset
-from itertools import product
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 
 
 class ChowRingIdeal(MPolynomialIdeal):
@@ -39,7 +40,7 @@ class ChowRingIdeal(MPolynomialIdeal):
         """
         return self._matroid
 
-    def _lattice_flats(self):
+    def _lattice_flats(self) -> tuple:
         r"""
         Return the ranks and chains of lattice of flats of the matroid.
 
@@ -67,7 +68,7 @@ class ChowRingIdeal(MPolynomialIdeal):
         chains = lattice_flats.chains()  # Only chains
         return (ranks, chains)
 
-    def flats_to_generator_dict(self):
+    def flats_to_generator_dict(self) -> dict:
         r"""
         Return the corresponding generators of flats/groundset elements of
         Chow ring ideal.
@@ -148,7 +149,7 @@ class ChowRingIdeal_nonaug(ChowRingIdeal):
         Chow ring ideal of Fano: Binary matroid of rank 3 on 7 elements,
          type (3, 0) - non augmented
     """
-    def __init__(self, M, R):
+    def __init__(self, M, R) -> None:
         r"""
         Initialize ``self``.
 
@@ -169,7 +170,7 @@ class ChowRingIdeal_nonaug(ChowRingIdeal):
         self._flats_generator = dict(zip(flats, gens))
         MPolynomialIdeal.__init__(self, poly_ring, self._gens_constructor(poly_ring))
 
-    def _gens_constructor(self, poly_ring):
+    def _gens_constructor(self, poly_ring) -> list:
         r"""
         Return the generators of ``self``.
 
@@ -217,7 +218,7 @@ class ChowRingIdeal_nonaug(ChowRingIdeal):
         J = list(atoms_gen.values())  # Linear generators
         return I + J
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -230,7 +231,7 @@ class ChowRingIdeal_nonaug(ChowRingIdeal):
         """
         return "Chow ring ideal of {} - non augmented".format(self._matroid)
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a LaTeX representation of ``self``.
 
@@ -273,7 +274,7 @@ class ChowRingIdeal_nonaug(ChowRingIdeal):
             algorithm = 'constructed'
         if algorithm != 'constructed':
             return super().groebner_basis(algorithm=algorithm, *args, **kwargs)
-        flats = sorted(list(self._flats_generator), key=len)
+        flats = sorted(self._flats_generator, key=len)
         ranks = {F: self._matroid.rank(F) for F in flats}
         gb = []
         R = self.ring()
@@ -291,7 +292,7 @@ class ChowRingIdeal_nonaug(ChowRingIdeal):
                 term += flats_gen[G]
             for G in lattice_flats.order_ideal([F]):
                 if G != F:
-                    gb.append(flats_gen[G]*(term) ** (ranks[F] - ranks[G]))
+                    gb.append(flats_gen[G] * (term) ** (ranks[F] - ranks[G]))
 
             gb.append(term ** ranks[F])
 
@@ -306,14 +307,15 @@ class ChowRingIdeal_nonaug(ChowRingIdeal):
             sage: ch = matroids.Z(3).chow_ring(QQ, False)
             sage: I = ch.defining_ideal()
             sage: I.normal_basis()
-            [1, Ax2x3y1, Ax1x3y2, Ax1x2y3, Ay1y2y3, Atx1y1, Atx2y2, Atx3y3, Atx1x2x3y1y2y3, Atx1x2x3y1y2y3^2]
+            [1, Ax2x3y1, Ax1x3y2, Ay1y2y3, Ax1x2y3, Atx3y3, Atx2y2, Atx1y1,
+             Atx1x2x3y1y2y3, Atx1x2x3y1y2y3^2]
             sage: set(I.gens().ideal().normal_basis()) == set(I.normal_basis())
             True
             sage: ch = matroids.AG(2,3).chow_ring(QQ, False)
             sage: I = ch.defining_ideal()
             sage: I.normal_basis()
-            [1, A012, A236, A046, A156, A345, A247, A057, A137, A258, A678,
-            A038, A148, A012345678, A012345678^2]
+            [1, A012, A345, A236, A156, A046, A247, A137, A057, A678, A258,
+             A148, A038, A012345678, A012345678^2]
             sage: set(I.gens().ideal().normal_basis()) == set(I.normal_basis())
             True
         """
@@ -421,7 +423,7 @@ class AugmentedChowRingIdeal_fy(ChowRingIdeal):
         Augmented Chow ring ideal of Wheel(3): Regular matroid of rank 3 on 6
         elements with 16 bases of Feitchner-Yuzvinsky presentation
     """
-    def __init__(self, M, R):
+    def __init__(self, M, R) -> None:
         r"""
         Initialize ``self``.
 
@@ -451,7 +453,7 @@ class AugmentedChowRingIdeal_fy(ChowRingIdeal):
                 self._flats_containing[x].append(F)
         MPolynomialIdeal.__init__(self, poly_ring, self._gens_constructor(poly_ring))
 
-    def _gens_constructor(self, poly_ring):
+    def _gens_constructor(self, poly_ring) -> list:
         r"""
         Return the generators of ``self``.
 
@@ -489,12 +491,13 @@ class AugmentedChowRingIdeal_fy(ChowRingIdeal):
              A4*B, A3*B, A2*B, A1*B, A0*B]
         """
         E = list(self._matroid.groundset())
-        Q = []
         L = []
         lattice_flats = Poset((self._flats, lambda x, y: x <= y))
         antichains = lattice_flats.antichains().elements_of_depth_iterator(2)
-        for F, G in antichains:
-            Q.append(self._flats_generator[F] * self._flats_generator[G])  # Quadratic generators
+
+        # Quadratic generators
+        Q = [self._flats_generator[F] * self._flats_generator[G]
+             for F, G in antichains]
 
         for x in E:
             term = poly_ring.zero()
@@ -509,7 +512,7 @@ class AugmentedChowRingIdeal_fy(ChowRingIdeal):
             L.append(term1)
         return Q + L
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         EXAMPLES::
 
@@ -520,7 +523,7 @@ class AugmentedChowRingIdeal_fy(ChowRingIdeal):
         """
         return "Augmented Chow ring ideal of {} of Feitchner-Yuzvinsky presentation".format(self._matroid)
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a LaTeX representation of ``self``.
 
@@ -555,11 +558,12 @@ class AugmentedChowRingIdeal_fy(ChowRingIdeal):
         gb = []  # reduced groebner basis with two eliminated cases
         E = list(self._matroid.groundset())
         poly_ring = self.ring()
-        reln = lambda x,y: x <= y
-        lattice_flats = Poset((self._flats, reln))
+
+        lattice_flats = Poset((self._flats, lambda x, y: x <= y))
         antichains = lattice_flats.antichains().elements_of_depth_iterator(2)
         for F, G in antichains:
-            gb.append(self._flats_generator[F] * self._flats_generator[G]) # non-nested flats
+            # non-nested flats
+            gb.append(self._flats_generator[F] * self._flats_generator[G])
         for i in E:
             term = poly_ring.zero()
             for H in self._flats_containing[i]:
@@ -576,7 +580,7 @@ class AugmentedChowRingIdeal_fy(ChowRingIdeal):
                 order_ideal_modified = lattice_flats.order_ideal([F])
                 order_ideal_modified.remove(F)
                 for G in order_ideal_modified:  # nested flats
-                    gb.append(self._flats_generator[G]*term1**(self._matroid.rank(F) - self._matroid.rank(G)))
+                    gb.append(self._flats_generator[G] * term1**(self._matroid.rank(F) - self._matroid.rank(G)))
 
         return PolynomialSequence(poly_ring, [gb])
 
@@ -612,10 +616,9 @@ class AugmentedChowRingIdeal_fy(ChowRingIdeal):
                 monomial_basis.append(R.one())
             else:
                 k = len(subset)
-                max_powers = []
-                max_powers.append(ranks[subset[0]])
-                for i in range(1, k):
-                    max_powers.append(ranks[subset[i]] - ranks[subset[i-1]])
+                max_powers = [ranks[subset[0]]]
+                max_powers.extend(ranks[subset[i]] - ranks[subset[i - 1]]
+                                  for i in range(1, k))
                 ranges = [range(1, p) for p in max_powers]
                 ranges[0] = range(1, max_powers[0] + 1)
                 for combination in product(*(r for r in ranges)):
@@ -675,7 +678,7 @@ class AugmentedChowRingIdeal_atom_free(ChowRingIdeal):
         Augmented Chow ring ideal of Wheel(3): Regular matroid of rank 3 on 6
         elements with 16 bases in the atom-free presentation
     """
-    def __init__(self, M, R):
+    def __init__(self, M, R) -> None:
         r"""
         Initialize ``self``.
 
@@ -696,7 +699,7 @@ class AugmentedChowRingIdeal_atom_free(ChowRingIdeal):
         self._flats_generator = dict(zip(self._flats, gens))
         MPolynomialIdeal.__init__(self, poly_ring, self._gens_constructor(poly_ring))
 
-    def _gens_constructor(self, poly_ring):
+    def _gens_constructor(self, poly_ring) -> list:
         r"""
         Return the generators of ``self``.
 
@@ -715,8 +718,7 @@ class AugmentedChowRingIdeal_atom_free(ChowRingIdeal):
         for F in self._flats:
             for x in F:
                 flats_containing[x].append(F)
-        reln = lambda x,y: x <= y
-        lattice_flats = Poset((self._flats, reln))
+        lattice_flats = Poset((self._flats, lambda x, y: x <= y))
         antichains = lattice_flats.antichains().elements_of_depth_iterator(2)
         for F, G in antichains:
             Q.append(self._flats_generator[F] * self._flats_generator[G])
@@ -728,11 +730,12 @@ class AugmentedChowRingIdeal_atom_free(ChowRingIdeal):
                 if term**2 not in Q:
                     Q.append(term**2)
 
-                if F not in flats_containing[x]:  # generators for every set of flats not containing element
-                    Q.append(self._flats_generator[F]*term)
+                if F not in flats_containing[x]:
+                    # generators for every set of flats not containing element
+                    Q.append(self._flats_generator[F] * term)
         return Q
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         EXAMPLES::
 
@@ -743,7 +746,7 @@ class AugmentedChowRingIdeal_atom_free(ChowRingIdeal):
         """
         return "Augmented Chow ring ideal of {} in the atom-free presentation".format(self._matroid)
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return the LaTeX output of the ring and generators of ``self``.
 

sage/matroids/database_matroids.py

@@ -2142,7 +2142,7 @@ def Z(r, t=True, groundset=None):
     Id = Matrix(GF(2), identity_matrix(r))
     J = Matrix(GF(2), ones_matrix(r))
     tip = Matrix(GF(2), ones_matrix(r, 1))
-    A = Id.augment(J-Id).augment(tip)
+    A = Id.augment(J - Id).augment(tip)
 
     M = Matroid(A)
     X = [f'x{i}' for i in range(1, r + 1)]
@@ -2259,7 +2259,7 @@ def Spike(r, t=True, C3=[], groundset=None):
     else:
         for S in C3:
             for xy in S:
-                if xy not in X+Y:
+                if xy not in X + Y:
                     raise ValueError(
                         "The sets in C3 must contain elements xi and yi only."
                     )
@@ -2431,13 +2431,13 @@ def Psi(r, groundset=None):
     for i in range(0, r):
         for k in range(1, r - 2):
             I0 = [f'a{i}', f'b{i}']
-            IK = [f'a{(i+k) % r}', f'b{(i+k) % r}']
+            IK = [f'a{(i + k) % r}', f'b{(i + k) % r}']
             for AB in generate_binary_strings(k - 1):
                 C = []
                 C += I0 + IK
                 j = 1
                 for z in AB:
-                    C += [f'{z}{(i+j) % r}']
+                    C += [f'{z}{(i + j) % r}']
                     j += 1
                 NSC += [C]
 
@@ -5104,6 +5104,17 @@ def BetsyRoss(groundset=None):
            'cjk', 'dfk', 'dgh', 'dij', 'efj', 'egk', 'ehi']
     M = Matroid(rank=3, nonspanning_circuits=NSC)
     M = _rename_and_relabel(M, "BetsyRoss", groundset)
+    pos = {'a': (0, 1.61000000000000),
+           'c': (0.946334256190882, -1.30251736094367),
+           'b': (1.53120099123520, 0.497517360943665),
+           'e': (-1.53120099123520, 0.497517360943665),
+           'd': (-0.946334256190882, -1.30251736094367),
+           'g': (0.590718333102580, -0.191936021350899),
+           'f': (0.365084007635076, 0.502495027562079),
+           'i': (-0.590718333102580, -0.191936021350899),
+           'h': (0, -0.621118012422360),
+           'k': (0, 0), 'j': (-0.365084007635076, 0.502495027562079)}
+    M._fix_positions(pos_dict=pos)
     return M
 
 
@@ -5322,6 +5333,6 @@ def _rename_and_relabel(M, name=None, groundset=None):
         M = M.relabel(dict(zip(M.groundset(), groundset)))
 
     if name is not None:
-        M.rename(name+": " + repr(M))
+        M.rename(name + ": " + repr(M))
 
     return M

sage/matroids/dual_matroid.py

@@ -333,8 +333,8 @@ class DualMatroid(Matroid):
         EXAMPLES::
 
             sage: M = matroids.catalog.Vamos().dual()
-            sage: N = M._minor(contractions=set(['a']), deletions=set([]))
-            sage: N._minor(contractions=set([]), deletions=set(['b', 'c']))
+            sage: N = M._minor(contractions=set(['a']), deletions=set())
+            sage: N._minor(contractions=set(), deletions=set(['b', 'c']))
             Dual of 'M / {'b', 'c'} \ {'a'}, where M is Vamos:
             Matroid of rank 4 on 8 elements with circuit-closures
             {3: {{'a', 'b', 'c', 'd'}, {'a', 'b', 'e', 'f'},