Chow rings of matroids

AUTHORS:

  • Shriya M

class sage.matroids.chow_ring.ChowRing(R, M, augmented, presentation=None)[source]

Bases: QuotientRing_generic

The Chow ring of a matroid.

The Chow ring of the matroid \(M\) is defined as the quotient ring

\[A^*(M)_R := R[x_{F_1}, \ldots, x_{F_k}] / (I_M + J_M),\]

where \((I_M + J_M)\) is the Chow ring ideal of matroid \(M\).

The augmented Chow ring of matroid \(M\) has two different presentations as quotient rings:

The Feitchner-Yuzvinsky presentation is the quotient ring

\[A(M)_R := R[y_{e_1}, \ldots, y_{e_n}, x_{F_1}, \ldots, x_{F_k}] / I_{FY}(M),\]

where \(I_{FY}(M)\) is the Feitchner-Yuzvinsky augmented Chow ring ideal of matroid \(M\).

The atom-free presentation is the quotient ring

\[A(M)_R := R[x_{F_1}, \ldots, x_{F_k}] / I_{af}(M),\]

where \(I_{af}(M)\) is the atom-free augmented Chow ring ideal of matroid \(M\).

See also

sage.matroids.chow_ring_ideal

Warning

Different presentations of Chow rings of non-simple matroids may not be isomorphic to one another.

INPUT:

  • M – matroid

  • R – commutative ring

  • augmented – boolean; when True, this is the augmented Chow ring and if False, this is the non-augmented Chow ring

  • presentation – string (default: None); one of the following (ignored if augmented=False)

    • "fy" - the Feitchner-Yuzvinsky presentation

    • "atom-free" - the atom-free presentation

REFERENCES:

EXAMPLES:

sage: M1 = matroids.catalog.P8pp()
sage: ch = M1.chow_ring(QQ, False)
sage: ch
Chow ring of P8'': Matroid of rank 4 on 8 elements with 8 nonspanning circuits
over Rational Field

>>> from sage.all import *
>>> M1 = matroids.catalog.P8pp()
>>> ch = M1.chow_ring(QQ, False)
>>> ch
Chow ring of P8'': Matroid of rank 4 on 8 elements with 8 nonspanning circuits
over Rational Field
class Element(parent, rep, reduce=True)[source]

Bases: QuotientRingElement

degree()[source]

Return the degree of self.

EXAMPLES:

sage: ch = matroids.Uniform(3, 6).chow_ring(QQ, False)
sage: for b in ch.basis():
....:     print(b, b.degree())
1 0
A01 1
A12 1
A02 1
A23 1
A13 1
A03 1
A34 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())
sage: v.degree()
2

>>> from sage.all import *
>>> ch = matroids.Uniform(Integer(3), Integer(6)).chow_ring(QQ, False)
>>> for b in ch.basis():
...     print(b, b.degree())
1 0
A01 1
A12 1
A02 1
A23 1
A13 1
A03 1
A34 1
A24 1
A14 1
A04 1
A45 1
A35 1
A25 1
A15 1
A05 1
A012345 1
A012345^2 2
>>> v = sum(ch.basis())
>>> v.degree()
2
homogeneous_degree()[source]

Return the (homogeneous) degree of self if homogeneous otherwise raise an error.

EXAMPLES:

sage: ch = matroids.catalog.Fano().chow_ring(QQ, True, 'fy')
sage: for b in ch.basis():
....:     print(b, b.homogeneous_degree())
1 0
Ba 1
Ba*Babcdefg 2
Bb 1
Bb*Babcdefg 2
Bc 1
Bc*Babcdefg 2
Bd 1
Bd*Babcdefg 2
Bbcd 1
Bbcd^2 2
Be 1
Be*Babcdefg 2
Bace 1
Bace^2 2
Bf 1
Bf*Babcdefg 2
Bdef 1
Bdef^2 2
Babf 1
Babf^2 2
Bg 1
Bg*Babcdefg 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: v = sum(ch.basis()); v
Babcdefg^3 + Babf^2 + Bace^2 + Badg^2 + Bbcd^2 + Bbeg^2 +
Bcfg^2 + Bdef^2 + Ba*Babcdefg + Bb*Babcdefg + Bc*Babcdefg +
Bd*Babcdefg + Be*Babcdefg + Bf*Babcdefg + Bg*Babcdefg +
Babcdefg^2 + Ba + Bb + Bc + Bd + Be + Bf + Bg + Babf + Bace +
Badg + Bbcd + Bbeg + Bcfg + Bdef + Babcdefg + 1
sage: v.homogeneous_degree()
Traceback (most recent call last):
...
ValueError: element is not homogeneous

>>> from sage.all import *
>>> ch = matroids.catalog.Fano().chow_ring(QQ, True, 'fy')
>>> for b in ch.basis():
...     print(b, b.homogeneous_degree())
1 0
Ba 1
Ba*Babcdefg 2
Bb 1
Bb*Babcdefg 2
Bc 1
Bc*Babcdefg 2
Bd 1
Bd*Babcdefg 2
Bbcd 1
Bbcd^2 2
Be 1
Be*Babcdefg 2
Bace 1
Bace^2 2
Bf 1
Bf*Babcdefg 2
Bdef 1
Bdef^2 2
Babf 1
Babf^2 2
Bg 1
Bg*Babcdefg 2
Bcfg 1
Bcfg^2 2
Bbeg 1
Bbeg^2 2
Badg 1
Badg^2 2
Babcdefg 1
Babcdefg^2 2
Babcdefg^3 3
>>> v = sum(ch.basis()); v
Babcdefg^3 + Babf^2 + Bace^2 + Badg^2 + Bbcd^2 + Bbeg^2 +
Bcfg^2 + Bdef^2 + Ba*Babcdefg + Bb*Babcdefg + Bc*Babcdefg +
Bd*Babcdefg + Be*Babcdefg + Bf*Babcdefg + Bg*Babcdefg +
Babcdefg^2 + Ba + Bb + Bc + Bd + Be + Bf + Bg + Babf + Bace +
Badg + Bbcd + Bbeg + Bcfg + Bdef + Babcdefg + 1
>>> v.homogeneous_degree()
Traceback (most recent call last):
...
ValueError: element is not homogeneous
monomial_coefficients(copy=None)[source]

Return the monomial coefficients of self.

EXAMPLES:

sage: ch = matroids.catalog.NonFano().chow_ring(QQ, True, 'atom-free')
sage: v = ch.an_element(); v
Aa
sage: v.monomial_coefficients()
{0: 0, 1: 1, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0,
 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0,
 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0,
 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0,
 34: 0, 35: 0}

>>> from sage.all import *
>>> ch = matroids.catalog.NonFano().chow_ring(QQ, True, 'atom-free')
>>> v = ch.an_element(); v
Aa
>>> v.monomial_coefficients()
{0: 0, 1: 1, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0,
 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0,
 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0,
 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0,
 34: 0, 35: 0}
to_vector(order=None)[source]

Return self as a (dense) free module vector.

EXAMPLES:

sage: ch = matroids.Uniform(3, 6).chow_ring(QQ, False)
sage: v = ch.an_element(); v
-A01 - A02 - A03 - A04 - A05 - A012345
sage: v.to_vector()
(0, -1, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, -1, -1, 0)

>>> from sage.all import *
>>> ch = matroids.Uniform(Integer(3), Integer(6)).chow_ring(QQ, False)
>>> v = ch.an_element(); v
-A01 - A02 - A03 - A04 - A05 - A012345
>>> v.to_vector()
(0, -1, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, -1, -1, 0)
basis()[source]

Return the monomial basis of the given Chow ring.

EXAMPLES:

sage: ch = matroids.Uniform(3, 6).chow_ring(QQ, True, 'fy')
sage: ch.basis()
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, 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, 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

>>> from sage.all import *
>>> ch = matroids.Uniform(Integer(3), Integer(6)).chow_ring(QQ, True, 'fy')
>>> ch.basis()
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)
>>> set(ch.defining_ideal().normal_basis()) == set(ch.basis())
True
>>> ch = matroids.catalog.Fano().chow_ring(QQ, False)
>>> ch.basis()
Family (1, Abcd, Aace, Adef, Aabf, Acfg, Abeg, Aadg, Aabcdefg,
 Aabcdefg^2)
>>> set(ch.defining_ideal().normal_basis()) == set(ch.basis())
True
>>> ch = matroids.Wheel(Integer(3)).chow_ring(QQ, True, 'atom-free')
>>> ch.basis()
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)
>>> set(ch.defining_ideal().normal_basis()) == set(ch.basis())
True
lefschetz_element()[source]

Return one Lefschetz element of the given Chow ring.

EXAMPLES:

sage: ch = matroids.catalog.P8pp().chow_ring(QQ, False)
sage: ch.lefschetz_element()
-2*Aab - 2*Aac - 2*Aad - 2*Aae - 2*Aaf - 2*Aag - 2*Aah - 2*Abc
- 2*Abd - 2*Abe - 2*Abf - 2*Abg - 2*Abh - 2*Acd - 2*Ace - 2*Acf
- 2*Acg - 2*Ach - 2*Ade - 2*Adf - 2*Adg - 2*Adh - 2*Aef - 2*Aeg
- 2*Aeh - 2*Afg - 2*Afh - 2*Agh - 6*Aabc - 6*Aabd - 6*Aabe
- 12*Aabfh - 6*Aabg - 6*Aacd - 12*Aacef - 12*Aacgh - 12*Aadeg
- 6*Aadf - 6*Aadh - 6*Aaeh - 6*Aafg - 6*Abcd - 12*Abceg
- 6*Abcf - 6*Abch - 12*Abdeh - 12*Abdfg - 6*Abef - 6*Abgh
- 6*Acde - 12*Acdfh - 6*Acdg - 6*Aceh - 6*Acfg - 6*Adef
- 6*Adgh - 6*Aefg - 6*Aefh - 6*Aegh - 6*Afgh - 56*Aabcdefgh

>>> from sage.all import *
>>> ch = matroids.catalog.P8pp().chow_ring(QQ, False)
>>> ch.lefschetz_element()
-2*Aab - 2*Aac - 2*Aad - 2*Aae - 2*Aaf - 2*Aag - 2*Aah - 2*Abc
- 2*Abd - 2*Abe - 2*Abf - 2*Abg - 2*Abh - 2*Acd - 2*Ace - 2*Acf
- 2*Acg - 2*Ach - 2*Ade - 2*Adf - 2*Adg - 2*Adh - 2*Aef - 2*Aeg
- 2*Aeh - 2*Afg - 2*Afh - 2*Agh - 6*Aabc - 6*Aabd - 6*Aabe
- 12*Aabfh - 6*Aabg - 6*Aacd - 12*Aacef - 12*Aacgh - 12*Aadeg
- 6*Aadf - 6*Aadh - 6*Aaeh - 6*Aafg - 6*Abcd - 12*Abceg
- 6*Abcf - 6*Abch - 12*Abdeh - 12*Abdfg - 6*Abef - 6*Abgh
- 6*Acde - 12*Acdfh - 6*Acdg - 6*Aceh - 6*Acfg - 6*Adef
- 6*Adgh - 6*Aefg - 6*Aefh - 6*Aegh - 6*Afgh - 56*Aabcdefgh

The following example finds the Lefschetz element of the Chow ring of the uniform matroid of rank 4 on 5 elements (non-augmented). It is then multiplied with the elements of FY-monomial bases of different degrees:

sage: ch = matroids.Uniform(4, 5).chow_ring(QQ, False)
sage: basis_deg = {}
sage: for b in ch.basis():
....:     deg = b.homogeneous_degree()
....:     if deg not in basis_deg:
....:         basis_deg[deg] = []
....:     basis_deg[deg].append(b)
....:
sage: basis_deg
{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
- 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
sage: for deg in basis_deg:
....:     if deg not in g_eq_maps:
....:         g_eq_maps[deg] = []
....:     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*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]}

>>> from sage.all import *
>>> ch = matroids.Uniform(Integer(4), Integer(5)).chow_ring(QQ, False)
>>> basis_deg = {}
>>> for b in ch.basis():
...     deg = b.homogeneous_degree()
...     if deg not in basis_deg:
...         basis_deg[deg] = []
...     basis_deg[deg].append(b)
....:
>>> basis_deg
{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]}
>>> g_eq_maps = {}
>>> lefschetz_el = ch.lefschetz_element(); lefschetz_el
-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
>>> for deg in basis_deg:
...     if deg not in g_eq_maps:
...         g_eq_maps[deg] = []
...     g_eq_maps[deg].extend([i*lefschetz_el for i in basis_deg[deg]])
....:
>>> 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*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]}
matroid()[source]

Return the matroid of self.

EXAMPLES:

sage: ch = matroids.Uniform(3, 6).chow_ring(QQ, True, 'fy')
sage: ch.matroid()
U(3, 6): Matroid of rank 3 on 6 elements with circuit-closures
{3: {{0, 1, 2, 3, 4, 5}}}

>>> from sage.all import *
>>> ch = matroids.Uniform(Integer(3), Integer(6)).chow_ring(QQ, True, 'fy')
>>> ch.matroid()
U(3, 6): Matroid of rank 3 on 6 elements with circuit-closures
{3: {{0, 1, 2, 3, 4, 5}}}
poincare_pairing(el1, el2)[source]

Return the Poincaré pairing of any two elements of the Chow ring.

EXAMPLES:

sage: ch = matroids.Wheel(3).chow_ring(QQ, True, 'atom-free')
sage: A0, A1, A2, A3, A4, A5, A013, A025, A04, A124, A15, A23, A345, A012345 = ch.gens()
sage: u = ch(-1/6*A2*A012345 + 41/48*A012345^2); u
-1/6*A2*A012345 + 41/48*A012345^2
sage: v = ch(-A345^2 - 1/4*A345); v
-A345^2 - 1/4*A345
sage: ch.poincare_pairing(v, u)
3

>>> from sage.all import *
>>> ch = matroids.Wheel(Integer(3)).chow_ring(QQ, True, 'atom-free')
>>> A0, A1, A2, A3, A4, A5, A013, A025, A04, A124, A15, A23, A345, A012345 = ch.gens()
>>> u = ch(-Integer(1)/Integer(6)*A2*A012345 + Integer(41)/Integer(48)*A012345**Integer(2)); u
-1/6*A2*A012345 + 41/48*A012345^2
>>> v = ch(-A345**Integer(2) - Integer(1)/Integer(4)*A345); v
-A345^2 - 1/4*A345
>>> ch.poincare_pairing(v, u)
3