tests.cpython-39.pyc

a

��c�}�@sT
dd
lZddl
mZ
ddlmZ
ddlmZ
ddlmZ
ddl	m
Z

ddlmZ
ddl
mZ
dd	lmZ
dd
lmZ
ddlmZmZ
ddlmZ
dd
lZd
d�Zdd�Zdd�Zdd�Zdd�ZGdd�d�Zdd�Z dd�Z!d7dd�
Z"d d!�Z#d"d#�Z$d$d%�Z%d&d'�Z&d(d)�Z'd8d+d,�
Z(d-d.�Z)d/d0�Z*Gd1d2�d2�Z+Gd3d4�d4�Z,d9d5d6�
Z-d
S):�N)
�product�
�QQ)
�lcm)
�gcd)
�SR)
�Matrix)
�free_module_element)
�WeightedIntegerVectors)
�
cached_method)�GeneralisedStratum�Stratum)
�	Signaturec

Cs�tt
|�
g
�
}
t|
j�
D]�\}}t|jj���
}|
�|f
d
fd
�||
�	|f
d
f|f
d
f�|
�
|
�d
|f
d
f�|f
d
f|f
d
f�d|
�
|
�d|f
d
f�|f
d
f|f
d
f�|
jksJ�
qdS)z�
    Compare calL and the 'error term' of cnb.

    EXAMPLES::

        sage: from admcycles.diffstrata.tests import test_calL
        sage: test_calL((1,1,1,1,-6))
        sage: test_calL((4,))
    r
������
N)
rr�	enumerate�bicsr�LG�prongs�values�calL�cnb�gen_pullback_taut�xi_at_level�ZERO)�sig�
X�
i�
B�ll�r �>/home/user/Introduction lectures/admcycles/diffstrata/tests.py�	test_calLs



@
�
*�
�r"c
Csd
S)a�
    EXAMPLES::

        sage: from admcycles.diffstrata import *
        sage: X=GeneralisedStratum([Signature((1,1,1,1,-6))])
        sage: (X.xi^2).evaluate(quiet=True)
        25

        sage: X=GeneralisedStratum([Signature((-2,-2,-2,-2,6))])
        sage: (X.xi^X.dim()).evaluate(quiet=True)
        30

        Testing normal bundles:

        sage: X=GeneralisedStratum([Signature((2,2,-2))])
        sage: td0 = X.taut_from_graph((0,))
        sage: td1 = X.taut_from_graph((1,))
        sage: td4 = X.taut_from_graph((4,))
        sage: td5 = X.taut_from_graph((5,))
        sage: td8 = X.taut_from_graph((8,))
        sage: assert X.ZERO == td0^2*td1 - td0*td1*td0  # not 'safe'  # doctest:+SKIP
        sage: assert X.ZERO == td0^2*td5 - td0*td5*td0  # not 'safe'  # doctest:+SKIP
        sage: assert X.ZERO == td0^2*td8 - td0*td8*td0  # not 'safe'  # doctest:+SKIP
        sage: assert (td8^3*td4).evaluate(quiet=True) == (td8^2*td4*td8).evaluate(quiet=True) == (td8*td4*td8^2).evaluate(quiet=True)

    Nr r r r r!�meromorphic_tests%sr#c
Csd
S)a�
    EXAMPLES::

        sage: from admcycles.diffstrata import *
        sage: X=GeneralisedStratum([Signature((2,))])
        sage: assert (X.xi^X.dim()).evaluate(quiet=True) == -1/640
        sage: ct=[i for i, B in enumerate(X.bics) if len(B.LG.edges) == 1]
        sage: ct_index = ct[0]  # compact type graph
        sage: ct_taut = X.taut_from_graph((ct_index,))
        sage: assert (X.c2_E*ct_taut).evaluate(quiet=True) == 1/48
        sage: banana_index = 1 - ct_index  # only 2 BICs!
        sage: banana_taut = X.taut_from_graph((banana_index,))
        sage: assert (X.c2_E*banana_taut).evaluate(quiet=True) == 1/24
        sage: assert (X.c1_E*banana_taut**2).evaluate(quiet=True) == -1/16
        sage: assert (X.c1_E*banana_taut*ct_taut).evaluate(quiet=True) == 1/24
        sage: assert (X.c1_E*ct_taut**2).evaluate(quiet=True) == -1/48
        sage: assert (ct_taut**3).evaluate(quiet=True) == 1/96
        sage: assert (banana_taut**3).evaluate(quiet=True) == 1/48
        sage: assert (ct_taut*banana_taut**2).evaluate(quiet=True) == 0
        sage: assert (ct_taut*ct_taut*banana_taut).evaluate(quiet=True) == -1/48

        sage: X=GeneralisedStratum([Signature((1,1))])
        sage: at1 = X.taut_from_graph((1,))
        sage: at2 = X.taut_from_graph((2,))
        sage: X.ZERO == at1^2*at2 + (-1)*at1*at2*at1
        True
        sage: X.ZERO == (-1)*(at1+at2)^3*at2 + at1^3*at2 + 3*at1^2*at2*at2  + 3*at1*at2^2*at2 + at2^3*at2
        True
        sage: X.ZERO == (-1)*(at1+at2)^4 + at1^4 + 4*at1^3*at2 + 6*at1^2*at2^2 + 4*at1^1*at2^3 + at2^4
        True
        sage: (X.xi^X.dim()).evaluate(quiet=True)
        0
        sage: psi1 = AdditiveGenerator(X,((),0),{1:1}).as_taut()
        sage: (X.xi^3*psi1).evaluate(quiet=True)
        -1/360
    Nr r r r r!�gengenustwotestsCs%r$c
Csd
S)a4
    Testing Normal bundles in min stratum (4):

    EXAMPLES::

        sage: from admcycles.diffstrata import *
        sage: X=GeneralisedStratum([Signature((4,))])

        sage: v_banana = [i for i, B in enumerate(X.bics) if B.LG.genera == [1,1,0]]
        sage: v_banana_taut=X.taut_from_graph((v_banana[0],))
        sage: g1_banana = [i for i, B in enumerate(X.bics) if B.LG.genera == [1,1]]
        sage: g1_banana_taut=X.taut_from_graph((g1_banana[0],))

        sage: assert g1_banana_taut**2*v_banana_taut + (-1)*g1_banana_taut*v_banana_taut*g1_banana_taut == X.ZERO
        sage: assert v_banana_taut**2*g1_banana_taut + (-1)*v_banana_taut*g1_banana_taut*v_banana_taut == X.ZERO

        sage: (X.xi_with_leg(quiet=True)^X.dim()).evaluate(quiet=True)  # long time  # optional - local
        305/580608
    Nr r r r r!�genusthreetestsksr%c
Csd
S)zw
    Tests in H(6): (think of smart NB test...)

    EXAMPLES::

        sage: from admcycles.diffstrata import *

    Nr r r r r!�genusfourtests�s	r&c@s4eZ
dZd
Zdd�Zd
dd�
Zddd	�
Zd
d�ZdS)�BananaSuitez�
    A frontend for the Stratum (k, 1, -k-1).

    This class models the situation of sec 10.2 of CMZ20
    with a method D for accessing the divisors in the
    notation of loc. cit. (either D(i), i=2,3,4 or D(i,a)
    for i=1,5).
    cCs&|
|_t
t|
d
|
d
f�
g
�
|_dS)zp
        Initialise the genus 1 stratum (k, 1, -k-1).

        Args:
            k (int): order of zero
        rN)�_krr�_X)�self�
kr r r!�__init__�s
zBananaSuite.__init__rcCs�|
d
kr�t|j
j�
D]�\}}|j�d�
d}|j�|�
dkrt|j�|�
�
dkrt|jj�
dkr||jj	�
�vr|jd
|j�|�
vs�Jd|�
�
|j
�|f
�

Sq�n*|
dk�
r<t|j
j�
D]t\}}|j�d�
d}|j�|�
d
kr�t|j�|�
�
dkr�|jd
|j�|�
v�
s$Jd|�
�
|j
�|f
�

Sq
n�|
dk�
r�t|j
j�
D]T\}}|j�d�
d}|j�|�
d
k�
rRt|j�|�
�
d
k�
rR|j
�|f
�

S�
qR�
n*|
dk�rt|j
j�
D]T\}}|j�d�
d}|j�|�
d
k�
r�t|j�|�
�
dk�
r�|j
�|f
�

S�
q�n�|
dk�r�t|j
j�
D]�\}}|j�d�
d}|j�|�
dk�r0t|j�|�
�
dk�r0t|jj�
dk�r0||jj	�
�v�r0|jd
|j�|�
v�s�Jd|�
�
|j
�|f
�

S�q0nd	Sd	S)
a

        The divisor using the notation of Sec. 10.2.

        Args:
            i (int): index 1,2,3,4,5
            a (int, optional): prong for i=1 or 5. Defaults to 1.

        Returns:
            ELGTautClass: Tautological class of the divisor D_{i,a}.
        rr
��z%r�r�N)
rr)rr�verticesonlevel�genus�len�ordersonvertex�edgesrrr(�taut_from_graph)r*r�
a�
br�
vr r r!�
D�s^



���
�




$

�




(





(






���
�z
BananaSuite.DFcCs<
g}d
d�}td|j
d�D]�}|�d|�djdd�
}t||j
d|�|j
t||j
d|��
tt||j
d|��
}|�||k�

|
std|||f�

qtd|j
�D]�}|�d|�djdd�
}t||j
|�|j
dt||j
|��
tt||j
|��
}|�||k�

|
s�td	|||f�

q�t	|�
S)
z�
        Check Prop 10.1

        Args:
            quiet (bool, optional): No output. Defaults to False.

        Returns:
            bool: Should always return True.
        cSs$|
|d
krtd�
td
�
SdSdS)Nr.rr)r+r7r r r!�delta�s

z BananaSuite.check.<locals>.deltarr.T�
�quietzD(1,%r)^2 = %r, RHS = %rr0zD(5,%r)^2 = %r, RHS = %r)
�ranger(r:�evaluaterrr�append�print�all)r*r=Z
check_listr;r7�si�rhsr r r!�check�s.



�
�





�
�


zBananaSuite.checkc


Csd
S)ai
        EXAMPLES::

            sage: from admcycles.diffstrata.tests import BananaSuite
            sage: B=BananaSuite(2)
            sage: B.check(quiet=True)
            True
            sage: (B._X.xi**2).evaluate(quiet=True) == QQ(2**4 - 1)/QQ(24)
            True
            sage: assert((B._X.xi_with_leg(quiet=True)*B.D(5,1)).evaluate(quiet=True) ==                           B._X.xi_at_level(0,B.D(5,1).psi_list[0][1].enh_profile,quiet=True).evaluate(quiet=True) == -1)
            sage: assert(B._X.xi_at_level(0,B.D(5,1).psi_list[0][1].enh_profile,leg=3,quiet=True).evaluate(quiet=True) == -1)

            sage: B=BananaSuite(5)
            sage: B.check(quiet=True)
            True
            sage: B=BananaSuite(5)
            sage: (B._X.xi**2).evaluate(quiet=True) == QQ(5**4 - 1)/QQ(24)
            True

            sage: B=BananaSuite(6)
            sage: assert((B._X.xi_with_leg(quiet=True)*B.D(5,2)).evaluate(quiet=True) ==                           B._X.xi_at_level(0,B.D(5,2).psi_list[0][1].enh_profile,leg=1,quiet=True).evaluate(quiet=True) ==                           B._X.xi_at_level(0,B.D(5,2).psi_list[0][1].enh_profile,leg=2,quiet=True).evaluate(quiet=True) ==                           B._X.xi_at_level(0,B.D(5,2).psi_list[0][1].enh_profile,leg=3,quiet=True).evaluate(quiet=True) ==                           B._X.xi_at_level(0,B.D(5,2).psi_list[0][1].enh_profile,leg=4,quiet=True).evaluate(quiet=True) == -12)

            sage: B=BananaSuite(10)
            sage: B.check(quiet=True)
            True
            sage: (B._X.xi**2).evaluate(quiet=True) == QQ(10**4 - 1)/QQ(24)
            True
        Nr �
r*r r r!�banana_tests�s"zBananaSuite.banana_testsN)
r)
F)�__name__�
__module__�__qualname__�__doc__r,r:rErGr r r r!r'�s

	

3
!r'c
Csd
S)a�

    Test the surjectivity of the _to_bic maps.

    EXAMPLES::

        sage: from admcycles.diffstrata import *
        sage: X=GeneralisedStratum([Signature((2,2,-2))])
        sage: assert all(set(X.DG.top_to_bic(i).keys()) == set(range(len(X.bics[i].level(0).bics))) for i in range(len(X.bics)))
        sage: assert all(set(X.DG.bot_to_bic(i).keys()) == set(range(len(X.bics[i].level(1).bics))) for i in range(len(X.bics)))
    Nr r r r r!�	rGRCtests
srLc
	Cs|tt
|�
g
�
}
|
�d
�
}t|
jd�
}t�}|D]:}|\}}|
j�|�
��D]}|�|d||df�

qLq0||ksxJ�
dS)a�

    Check if gluing in middle bics gives (at least as a set) all length three profiles.

    Maybe think of some more sophisticated test...

    Args:
        sig (tuple): Signature tuple.

    EXAMPLES::

        sage: from admcycles.diffstrata.tests import middle_level_degeneration
        sage: middle_level_degeneration((1,1))
        sage: middle_level_degeneration((2,2,-2))
        sage: middle_level_degeneration((4,))
        sage: middle_level_degeneration((2,2,2,-6))
    r.r-r
rN)	rr�enhanced_profiles_of_length�set�lookup_list�DG�
middle_to_bicr�add)	rrZthree_level_graphsZfour_level_profiles_set�seen�ep�
p�_ir8r r r!�middle_level_degeneration)
s








rWFc
CsP
tt
|�
g
�
}|��d
}|j|D�
]$}|�|�
}t|�
D�
]
\}}||f}|jdd�
|�||�jdd�
}	|j	|��
d�
��}
|
s�td||	|
f�

|
dkr�|	dks�J�
t|�
D]�}|�
|�
}|��d
kr�q�d}
|j
D]j}|j|||f|dd�jdd�
}|
�
s|}
|
�
std|||f�

|
r�|
|k�
s0J�
|dkr�|	|ks�J�
q�q�q<q$dS)	a�
    Tests on each dimension 1 graphs of the stratum with signature sig:
    We test on each one-dimensional level if the evaluation of the xi glued in at
    that level is the same (for every leg!) as the product of the graph with xi on
    the whole stratum.

    Args:
        sig (tuple): Signature of a stratum.
        quiet (bool, optional): No output. Defaults to False.

    EXAMPLES::

        sage: from admcycles.diffstrata.tests import leg_test
        sage: leg_test((6,1,-7),quiet=True)
        sage: leg_test((3,-1,-2),quiet=True)
        sage: leg_test((1,1),quiet=True)
        sage: leg_test((2,2,-2),quiet=True)  # long time
    rTr<r
z/Graph %r: xi evaluated: %r (dim of Level 0: %r)N)�legr=zlevel: %r, leg: %r, xi ev: %r)rr�dimrO�lookupr�xi_with_legr6r?�lookup_graph�levelrAr>�leg_dictr)rr=r�
drU�
componentsrr�enh_profileZglobal_xi_prodZtop_dim�
l�
L�firstrXZ
level_xi_prodr r r!�leg_testE
sN









�
�


�










�
�



�


rec
Csd
S)z�
    Tests of stratum class calculations.

    EXAMPLES::

        sage: from admcycles.diffstrata import *

        sage: X=GeneralisedStratum([Signature((23,5,-13,-17))])
        sage: assert X.res_stratum_class([(0,2)]).evaluate(quiet=True) == 5
    Nr r r r r!�stratumclasstestsy
srfc
Cs�tt
|�
g
�
}
|
��}ttt|
j�
�
|d
�D]�}td�

t|�

|
�|df
�
}|
�|df
�
}td|�D]0}||
�||f
�
9}||
�|d|f
�
9}qjt|d|d�
|j	dd�
}|j	dd�
}||dkr,t|d||�
t
�
q,d	S)
a�

    Run a (large) commutativity check on Stratum(sig)
    to check the normal bundle.

    More precisely, we check all top-degree products
    of BICs in this stratum, multiplying them from
    right-to-left and from left-to-right and checking
    that the evaluations agree.

    Args:
        sig (tuple): signature tuple

    Raises:
        RuntimeError: raised if a commutator doesn't
            evaluate to 0.
    �
�repeatzStarting IPsr
rrTr<z gives N)rrrYrr>r3rrAr6r?�RuntimeError)rr�
n�
T�PRZRPrr r r!�commutativity_check�
s 














rmc
Cs~tt
|d
|d
f�
g
�
}
|
jjdd�
t||d
�
td�
ksDJ�
|
jjdd�
td
�
td�
|
jdd|
jjdd�
S)a|

    Check c2 evaluation for the bananas.

    Args:
        k (int): zero of the banana

    Returns:
        RationalNumber: difference of evaluate of c2 and c2
            formula in terms of c1 and ch2 (should be 0!!!)

    EXAMPLES::

        sage: from admcycles.diffstrata.tests import c2_banana_tests
        sage: for k in range(1,10): assert c2_banana_tests(k) == 0
    rTr<�r.������rr�c2_Er?r�c1_E�ch2_E�r+rr r r!�c2_banana_tests�
s

*

�ruc
Cs\tt
|�
g
�
}
|
jjd
d�
}|td�
td�
|
jdd|
jjd
d�
}|dksXJ�
|S)z�
    Compare c2_E to (ch_1^2 - 2ch_2)/2.

    EXAMPLES::

        sage: from admcycles.diffstrata.tests import c2_test
        sage: assert c2_test((1,1,1,1,-6)) == 2
        sage: assert c2_test((-2,-2,-2,-2,6)) == 2
    Tr<rr.ror
rp)rrZc2ev�diffr r r!�c2_test�
s



0

rwc
Cs:tt
||f�
g
�
}
|
jjd
d�
t||d�
td�
kS)z�
    Check the Euler characteristic of (k,-k) (modular curves).

    EXAMPLES::

        sage: from admcycles.diffstrata.tests import c1_test
        sage: for k in range(2,20): assert c1_test(k)
    Tr<r�)rrrrr?rrtr r r!�c1_test�
s	
ryr-cCs"
tt
|�
g
�
}|��|
}td
�

|jdd�
}|d|
|�|
�
}|dkr`t|jdd�
�

dStd�

ttt	|j
�
�
|d	�D]D}|}|D]}||�|f
�
9}q�|jdd�
}	t|	d
d�
tj
��
q~t�
|dk�
rtd|�

|�|�
D],}
t||j|
�jdd�
d
d�
tj
��
q�t�
dS)
a1
    Compare ch1_pow(deg) to c1^deg in Stratum(sig_tuple).

    We multiply with classes to obtain top-degree and then
    evaluate.

    This should produce a series of 0s.

    Args:
        sig_tuple (tuple): signature tuple
        deg (int, optional): degree. Defaults to 3.

    EXAMPLES::

        sage: from admcycles.diffstrata.tests import ch1_pow_test
        sage: ch1_pow_test((1,1), 2)
        Calculating difference...
        Products of BICs:
        0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
        Products with graphs of codim 2:
        0 0 0 0
    �Calculating difference...r�
�uptor
Tr<NzProducts of BICs:rg�
 �
�end�!Products with graphs of codim %r:)rrrYrA�
chern_poly�ch1_powr?rr>r3rr6�sys�stdout�flushrM)Z	sig_tuple�degr�codim�
crv�pr�exprr8�evrTr r r!�ch1_pow_test�
s.






















r�c
sVtt
|�
g
�
�td
�

����
td�

��
fdd�ttd���d��
D�
}
g}t����
D�
]�}|
|��srJ�
|
|jr�|
|jddj	���|ks�J�
|dkr�tddd	�
t
j��
|
|j
d
d�
}t|�

|�|�

q\td|�

ttt�j�
t|�
�
|d
�D]�}|
|}|D]h}|t�j�
k�
rRtd|dd	�
|��|f
�
9}n0|t�j�
d}td|dd	�
|��|�
9}�
q|j
d
d�
}t|dd	�
|�|�

t
j��
�
qt�
|dkr\td|�

��|�
D]R}	td|	f
dd	�
|
|�j|	�j
d
d�
}t|dd	�
t
j��
|�|�

�
q�t�
q\tdd�|D�
�
}
td|
�
|
S)aR
    Compare chern_poly and chern_class.

    We multiply with classes to obtain top-degree and then
    evaluate.

    Args:
        sig (tuple): signature tuple

    Returns:
        bool: True

    EXAMPLES::

        sage: from admcycles.diffstrata.tests import chern_poly_test
        sage: chern_poly_test((2,))  # doctest:+ELLIPSIS
        Calculating Chern Polynomial via character...
        Calculating difference...
        Comparing top classes: 0
        Comparing Products of 1 BICs and psi classes:
        BIC 0 0 BIC 1 0 Psi 1 0
        Comparing Products of 2 BICs and psi classes:
        BIC 0 BIC 0 0 BIC 0 BIC 1 0 BIC 0 Psi 1 0 BIC 1 BIC 0 0 BIC 1 BIC 1 0 BIC 1 Psi 1 0 Psi 1 BIC 0 0 Psi 1 BIC 1 0 Psi 1 Psi 1 0
        Products with graphs of codim 2:
        Profile (..., 0) 0
        All tests passed: True
        True
    z-Calculating Chern Polynomial via character...rzc
sg|]}
�
|
��|
�
�qSr )
�chern_class��.0r�rr�r r!�
<listcomp>/�z#chern_poly_test.<locals>.<listcomp>rr
zComparing top classes:r}r~Tr<z.Comparing Products of %r BICs and psi classes:rg�BIC %r�Psi %rr��
Profile %rc
ss|]}
|
dkV
qd
S)r
Nr )r�r�r r r!�	<genexpr>Ur�z"chern_poly_test.<locals>.<genexpr>zAll tests passed:)rrrAr��reversedr>rY�is_equidimensional�psi_list�degreer�r�r�r?r@rr3rr6�psirMrB)rrvZevsr�r�r�r�r8�psi_numrT�passedr r�r!�chern_poly_testsX



&





$










"


























r�c
Cs@g}
|D]$}td
|�
|
�
t|�
�

td�

qtdt|
�
�
dS)a�
    Apply chern_poly_test to a list of signatures.

    Args:
        sig_list (iterable): list of signature tuples.

    EXAMPLES::

        sage: from admcycles.diffstrata.tests import chern_poly_tests
        sage: chern_poly_tests([(0,),(2,-2)])
        Entering Stratum (0,)
        Calculating Chern Polynomial via character...
        Calculating difference...
        Comparing top classes: 0
        All tests passed: True
        Done.
        Entering Stratum (2, -2)
        Calculating Chern Polynomial via character...
        Calculating difference...
        Comparing top classes: 0
        All tests passed: True
        Done.
        All strata tests passed: True
    zEntering StratumzDone.zAll strata tests passed:N)rAr@r�rB)�sig_listZ	check_vecrr r r!�chern_poly_testsZs






r�c@s:eZ
dZd
Zd
dd�
Zdd�Zdd�Zd	d
�Zdd�ZdS)�C3_coefficient_hunterzv
    A class that illustrates how to use symbolic variables to
    test coefficients in explicit formulas of c_k.
    NcCsbd
|_d|_
|durd|_n||_t�d|j�|_}t|�
|_d|_g|_	|
du
r^|�
|
�

dS)N�!r-Zc3_E�
t)ZNUM_VARS�DEG�fctr�varr��list�var_list�
M�	constants�add_stratum)r*rr�r�r r r!r,�s










zC3_coefficient_hunter.__init__cCsn
tt
|
�
g
�
}td
�

t||j��|j|jd�
|j}|��|j}|dkrd|�|j	dd�
�

dStd�

t
tt|j
�
t|
�
�
|d�D]�}|}|D]d}|t|j
�
kr�td|d	d
�
||�|f
�
9}q�|t|j
�
d}td|d	d
�
||�|�
9}q�|j	dd�
}	|�|	�

q�|dk�
rjtd
|�

|�|�
D]4}
td|
f
d	d
�
|�||j|
�j	dd�
�

�
q4dS)Nrzr{r
Tr<zProducts of BICs and Psis:rgr�r}r~rr�r�r�)rrrA�getattrr�r�r�rY�_add_eqr?rr>r3rr6r�rM)r*rrr�r�r�rvr8r�r�rTr r r!r��s4


"





"















�z!C3_coefficient_hunter.add_stratumcs�td
��

�dkrdS�f
dd�|j
D�
}��dd����D�
�
}|jdur^tt|g
�|_n|j�tt|g
��
|_|j�	|�

dS)NzAdding equation: %rr
c
sg|]}
��|
�
�qSr )
�coefficient�r�r9�
r�r r!r��r�z1C3_coefficient_hunter._add_eq.<locals>.<listcomp>c
Ssi|]
}
|
d�qS)
r
r r�r r r!�
<dictcomp>�r�z1C3_coefficient_hunter._add_eq.<locals>.<dictcomp>)
rAr��
substitute�free_variablesr�rr�stackr�r@)r*r��eqn�cstr r�r!r��s








zC3_coefficient_hunter._add_eqc

Cs|j�
tt|j��
|_dS�
N)r��solve_rightr	rr��solutionrFr r r!�solve�s


�zC3_coefficient_hunter.solvec
Cspd
g
}
|
�t
|j�
�

|
�d|j���

|
�d�

|
�t
|j�
�

|��
|
�d�

|
�t
|j�
�

d�|
�
S)NzCoefficient Matrix:
z	
Rank: %rz
Constants:
z
Solution:
�)r@�strr��rankr�r�r��join)r*�
sr r r!�__str__�s










zC3_coefficient_hunter.__str__)NN)	rHrIrJrKr,r�r�r�r�r r r r!r�{s

r�c@steZ
dZd
Zdd�Zedd��
Zeddd�
�
Zd	d
�Zdd�Z	dd
d�
Z
ddd�
Zddd�
Zddd�
Z
ddd�
ZdS)�IntersectionMatrixz/
    The intersection matrix of a stratum.
    cCst|
�
|_
i|_|��
d
S)zg
        Initialise stratum and cache.

        Args:
            sig (tuple): signature tuple
        N)r
r�	info_vecs�codim_one_summary)r*rr r r!r,�s


zIntersectionMatrix.__init__c	s�
td
|
dd�
t
j��
g}g}t|
d�
D�
]J}|
|}|j�|�
D�
].}|j�|�
�|dkr�|���	��

|�|if�

qH�f
dd�t�j
d�
D�
�i�d}t��
D] \}}|dkr�|�|<|d7}q�t|dg
t
��
�D]��
t�
��fdd	�tt
��
�
D�
�
�
rq��	�}	t�
�
D].\}}
|j��|||
�}|j�|	||�}	�
q|�|	�

|�|�
f
d
d����D�
f�

q�qHq.tdt
|�
�

||j|
<|S)
z�
        Classes of codimension k, that graphs with <= k levels
        with xi powers on levels to reach deg k.

        Args:
            k (int): degree

        Returns:
            list: list of ELGTautClasses of deg k
        z"Calculating classes of codim %r...r}r~rr
c
sg|]}
��|
�
�qSr )
�	level_dim)r�rb)
�AGr r!r��r�z0IntersectionMatrix.codim_xis.<locals>.<listcomp>c
3s"|]}
�|
�
�|
kV
qdSr�r r�)�	exponents�
level_dims�pos_dim_level_dictr r!r��s
�z/IntersectionMatrix.codim_xis.<locals>.<genexpr>c
si|]\}
}|�|
�qSr r )r�rrb)
r�r r!r�r�z0IntersectionMatrix.codim_xis.<locals>.<dictcomp>z%r found)rAr�r�r�r>rrM�additive_generatorr@�as_tautr�rr
r3�any�xi_at_level_pow�intersection�itemsr�)r*r+�classesZinfo_vecrbZxi_degrTrrY�prod�
eZcurr_xir )r�r�r�r�r!�	codim_xis�sN

















�

�





�



�



zIntersectionMatrix.codim_xisrc	s���|
�
}���j
��|
�
�
��
fd
d�tt|�
�
D�
}td|
dd�
tj��
t	|�
D]h\}}t	�
�
D]V\}}||}|�
�s�J�
|�j
jks�|jddj
�j
��ks�J�
|��|||<qlq\td�

|S)	a

        Matrix of evaluations of top-degree classes (products of codim_xis(k)
        and codim_xis(dim-k)).

        Args:
            k (int, optional): degree. Defaults to 1.

        Returns:
            list: list of lists of rational numbers.
        c
s&g|]}
�f
dd
�tt
�
�
�
D�
�qS)c
sg|]}
�jj
�qSr )rr�r��
_rFr r!r�r�z<IntersectionMatrix.int_matrix.<locals>.<listcomp>.<listcomp>)r>r3r��r*Z	y_classesr r!r�s
�z1IntersectionMatrix.int_matrix.<locals>.<listcomp>z/Calculating intersection matrix for codim %r...r}r~r
rzDone!)r�rrYr>r3rAr�r�r�rr�rr�r�r?)	r*r+Z	x_classesr�r�
x�
j�
yr�r r�r!�
int_matrixs




�






*

zIntersectionMatrix.int_matrixc
CsBt|j
�

|�d
�
}
t|
�
��}tdt|
�
t|
d�
|f�

dS)z1
        Display codim 1 matrix summary.
        rz#Codim 1: Rank of %r x %r matrix: %rr
N)rArr�rr�r3)r*r��rkr r r!r�'s




z$IntersectionMatrix.codim_one_summaryc
Cs\t|j
�

t|j
��d
�
D]:}
|�|
�
}t|�
��}td|
t|�
t|d�
|f�

qdS)z:
        Summary of matrices in all codimensions.
        rz$Codim %r: Rank of %r x %r matrix: %rr
N)rArr>rYr�rr�r3)r*r+r�r�r r r!�summary0s






�zIntersectionMatrix.summarycCs,tt
|�|
�
�
�
D]}|�|d
|
�
qdS)z�
        Human readable output of int_matrix(k) values.

        Args:
            k (int, optional): degree. Defaults to 1.
        rN)r>r3r��	print_row)r*r+�rowr r r!�print_matrix;s
zIntersectionMatrix.print_matrixcCsT||jv
r|�
|�

|j||
\}}t|�
}|��D]\}}|d
||f7}q6|S)a

        A string representation of the i-th codim k class.

        Args:
            i (int): index of codim_xis(k)
            k (int, optional): degree. Defaults to 1.

        Returns:
            String: string description of which levels carry xis.
        z level %r: xi^%r,)r�r�r�r�)r*rr+rTr_r�rbr�r r r!�infoEs







zIntersectionMatrix.infocCs.|�|
d
|�d|�|d
|j
��|�S)a�

        Human-readable representation of the entry row, col of int_matrix(k).

        Note that this prints the classes being multiplied, not the values.

        Args:
            row (int): row index (math notation, i.e. starting at 1)
            col (int): col index (math notation, i.e. starting at 1)
            k (int, optional): degree. Defaults to 1.

        Returns:
            String: info of the two factors at this entry
        rz * )r�rrY)r*r��colr+r r r!�entryXszIntersectionMatrix.entryc	CsX|�|�
}t
d
|
�

t||
d�
D],\}}t
d|d|�|
|d|�|f�

q&dS)z�
        Human-readable output of the row of int_matrix(k)

        Args:
            row (int): row (math notation, i.e. starting at 1)
            k (int, optional): degree. Defaults to 1.
        zRow %rrzCol %r: %s value: %rN)r�rArr�)r*r�r+r�r��valuer r r!r�is	




�zIntersectionMatrix.print_rowc	Cs\|�|�
}t
d
|
�

tt|�
�
D]4}t
d|d|�|d|
|�|||
df�

q"dS)z�
        Human-readable output of the col of int_matrix(k)

        Args:
            col (int): column (math notation, i.e. starting at 1)
            k (int, optional): degree. Defaults to 1.
        zCol %rzRow %r: %s value: %rrN)r�rAr>r3r�)r*r�r+r�r�r r r!�	print_colxs	




&�zIntersectionMatrix.print_colN)
r)
r)
r)
r)
r)
r)rHrIrJrKr,rr�r�r�r�r�r�r�r�r�r r r r!r��s


3
	




r�c
Cs
td
|f
dd�
t
j��
t|�
}|
dkr<td�

|j}n|j}td�

|jd}|j}t	j	�
||d�D]�}t|���
dkr�qjtd	|d
d�
t
j��
|�
|�
}||jkr�td�

qj||����}t	j	�t	j	�|�
g
�
|����}	t||	���

qjdS)Nz/Testing non-horizontal push-pull for stratum %rr}r~�xiz	using xi:z
using [1]:r
rz%r: r�r)rAr�r�r�r
r��ONE�_g�_n�	admcycles�list_stratar3�genera�boundary_pullbackr�to_prodtautclass�pushforward�	tautclass�
decstratum�is_zero)
rZT_namerrk�
grj�
GZpullbackZLHSZRHSr r r!�	push_pull�s2























�

�r�)
F)
r-)
N).r��	itertoolsr�sage.rings.rational_fieldr�sage.arith.functionsr�sage.arith.miscr�sage.symbolic.ringr�sage.matrix.constructorr� sage.modules.free_module_elementr	�%sage.combinat.integer_vector_weightedr
�sage.misc.cachefuncr�'admcycles.diffstrata.generalisedstratumrr
�admcycles.diffstrata.sigrZadmcycles.admcyclesr�r"r#r$r%r&r'rLrWrerfrmrurwryr�r�r�r�r�r�r r r r!�<module>
sD







(
4#
0L!LD