unlisted
ubuntu2004a
��c�Z � @ s\ d dl mZ d dlmZ d dlmZ d dlZd dlZd dl Zd dl
m Z G dd� de�Z dS )� )�
SageObject)�
cached_method)�QQN)�hash_AGc @ sP e Zd ZdZd@dd�Zedd� �Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z dd� Z dd� Z
edd� �Zedd� �Zedd� �Zedd � �Zed d � �Zed d � �Zed!d"� �Zed#d$� �Zed%d&� �Zd'd(� Zed)d*� �Zed+d,� �Zed-d.� �Z ed/d0� �Z edAd1d2��Z edBd3d4��Z edCd5d6��Z d7d8� Z!d9d:� Z"dDd<d=�Z#dEd>d?�Z$dS )F�AdditiveGeneratora
Product of Psi classes on an EmbeddedLevelGraph (of a stratum X).
The information of a product of psi-class on an EmbeddedLevelGraph, i.e. a
leg_dict and an enhanced_profile, where leg_dict is a dictionary on the legs
leg -> exponent of the LevelGraph associated to the enhanced profile, i.e.
(profile,index) or None if we refer to the class of the graph.
We (implicitly) work inside some stratum X, where the enhanced profile
makes sense.
This class should be considered constant (hashable)!
Nc C s� || _ t||�| _t|d �|d f| _|| _| j j|� | _i | _|durr|D ]"}| jj �
| jj � |��| j|< qNi | _ | jD ]D}z| j | j| �
|� W q~ ty� |g| j | j| < Y q~0 q~dS )a�
AdditiveGenerator for psi polynomial given by leg_dict on graph
corresponding to enh_profile in X.
Args:
X (GeneralisedStratum): enveloping stratum
enh_profile (tuple): enhanced profile (in X)
leg_dict (dict, optional): dictionary leg of enh_profile -> exponent
encoding a psi monomial. Defaults to None.
r � N)�_Xr �_hash�tuple� _enh_profile� _leg_dict� lookup_graph�_G� _level_dict�LG� level_number�
levelofleg�_inv_level_dict�append�KeyError)�self�X� enh_profile�leg_dict�l�leg� r �J/home/user/Introduction lectures/admcycles/diffstrata/additivegenerator.py�__init__ s"
�
zAdditiveGenerator.__init__c C s6 |d du rd}n t |d �}| ||d |d f|�S )z�
AdditiveGenerator from a hash generated with hash_AG.
Args:
X (GeneralisedStratum): Enveloping stratum.
hash (tuple): hash from hash_AG
Returns:
AdditiveGenerator: AG from hash.
r Nr � )�dict)�clsr �hashr r r r � from_hash? s zAdditiveGenerator.from_hashc C s
t | j�S �N)r" r �r r r r �__hash__Q s zAdditiveGenerator.__hash__c C s* z| j |j kW S ty$ t Y S 0 d S r$ )r �AttributeError�NotImplemented�r �otherr r r �__eq__T s zAdditiveGenerator.__eq__c C s d| j | j| jf S )Nz2AdditiveGenerator(X=%r,enh_profile=%r,leg_dict=%r))r r r r% r r r �__repr__Z s �zAdditiveGenerator.__repr__c C sL d}| j d ur8| j D ]"}|d|| j | | j| f 7 }q|d| jf 7 }|S )N� z,Psi class %r with exponent %r on level %r * zGraph %r)r r r )r �strr r r r �__str__a s
�zAdditiveGenerator.__str__c s� z(| j |j ks| j|jkr tW S |j� W n ty> t Y S 0 | jdu rPi �n| j�� du rbi � � �fdd�t��t� �B D �}| j �| j|�S )a?
Multiply to psi products on the same graph (add dictionaries).
Args:
other (AdditiveGenerator): Product of psi classes on same graph.
Returns:
AdditiveGenerator: Product of psi classes on same graph.
EXAMPLES::
Also works without legs.
Nc s& i | ] }|�� |d �� � |d � �qS )r )�get��.0r �Zother_leg_dictZ
self_leg_dictr r �
<dictcomp>� s �z-AdditiveGenerator.__mul__.<locals>.<dictcomp>)r r r( r r' �set�additive_generator)r r* � new_leg_dictr r3 r �__mul__j s
�zAdditiveGenerator.__mul__c C s | � |� d S r$ )r8 r) r r r �__rmul__� s zAdditiveGenerator.__rmul__c C s
| � |�S r$ )�pow)r �nr r r �__pow__� s zAdditiveGenerator.__pow__c C s | j S r$ )r r% r r r r � s z AdditiveGenerator.enh_profilec C s | j du rdS t| j �� �S dS )z7
Sum of powers of psi classes of self.
Nr )r �sum�valuesr% r r r �
psi_degree� s
z AdditiveGenerator.psi_degreec C sf | j | j�� krdS | jdkr"dS t| jd �D ]0}| �|�dksFJ �| �|�| �|�kr0 dS q0dS )z�
Check if, on any level, the psi degree is higher than the dimension.
Returns:
bool: False if the class is 0 for dim reasons, True otherwise.
Fr Tr )�degreer �dim�codim�range� level_dim�degree_on_level�r r r r r � dim_check� s
��zAdditiveGenerator.dim_checkc C s t | jd �S )zz
The codimension of the graph (number of levels)
Returns:
int: length of the profile
r )�lenr r% r r r rB � s zAdditiveGenerator.codimc C s | j | j S )z
Degree of class, i.e. codimension of graph + psi-degree
Returns:
int: codim + psi_degree
)rB r? r% r r r r@ � s zAdditiveGenerator.degreec C s | j S r$ �r r% r r r r � s zAdditiveGenerator.leg_dictc C s | j S )z5
The dictionary mapping leg -> level
)r r% r r r �
level_dict� s z AdditiveGenerator.level_dictc C s | j S )z�
The dictionary mapping level -> list of legs on level.
Returns:
dict: level -> list of legs.
)r r% r r r �inv_level_dict� s z AdditiveGenerator.inv_level_dictc sZ |t � jd �vr"td|� f ��z t� fdd�� j| D ��W S tyT Y dS 0 dS )a.
Total degree of psi classes on level.
Args:
level (int): (relative) level number (i.e. 0...codim)
Raises:
RuntimeError: Raised for level number out of range.
Returns:
int: sum of exponents of psis appearing on this level.
r z Illegal level number: %r on %rc 3 s | ]}� j | V qd S r$ rI �r2 r r% r r � <genexpr>� s �z4AdditiveGenerator.degree_on_level.<locals>.<genexpr>r N)rC rB � RuntimeErrorr= r r )r �levelr r% r rE � s
� �
z!AdditiveGenerator.degree_on_levelc C s | j �|�S )z�
Level of underlying graph.
Args:
level_number (int): (relative) level number (0...codim)
Returns:
LevelStratum: Stratum at level level_number of self._G.
)r rO rF r r r rO � s
zAdditiveGenerator.levelc C s | j �|�}|�� S )z�
Dimension of level level_number.
Args:
level_number (int): (relative) level number (i.e. 0...codim)
Returns:
int: dimension of GeneralisedLevelStratum
)r rO rA )r r rO r r r rD s zAdditiveGenerator.level_dimc C s� z| j W S ty� d}| jjj�� D ] }||9 }q(| j\}}d}|D ]}|| jj| j 9 }qHt
|�t
|t | jj � � }|| _ | j Y S 0 dS )z�
The stack factor, that is the product of the prongs of the underlying graph
divided by the product of the ells of the BICs and the automorphisms.
Returns:
QQ: stack factor
r N)
Z
_stack_factorr' r r �prongsr> r r �bics�ellr rH �
automorphisms)r �prod�k�p�_Z bic_contr�i� stack_factorr r r rY s
�z AdditiveGenerator.stack_factorc C s t jj�| jd| fg�S )zU
Helper method, returns [(1,self)] as default input to ELGTautClass.
r )� admcycles�
diffstrata� elgtautclass� ELGTautClassr r% r r r �as_taut0 s �zAdditiveGenerator.as_tautc C s | j �| j|�S )a
Check if ambient_enh_profile is an ambient graph, i.e. self is a degeneration
of ambient_enh_profile.
INPUT:
ambient_enh_profile: tuple
An enhanced profile.
OUTPUT:
True if there exists a leg map, False otherwise.
)r �is_degenerationr )r Zambient_enh_profiler r r �
is_in_ambient8 s z AdditiveGenerator.is_in_ambientc C sN |du r| j j}d}n | j j|� }|dkr.|S | j �| �� | �|d |�|�S )a
Recursively calculate the n-th power of self (in amb), caching all results.
Args:
n (int): exponent
amb (tuple, optional): enhanced profile. Defaults to None.
Returns:
ELGTautClass: self^n in CH(amb)
N�r r r r )r �ONE�taut_from_graph� intersectionr^ r: )r r; �ambrb r r r r: I s zAdditiveGenerator.powc C s: g }| � |||�D ]}|�|j� qtjjj| j|dd�S )ar
exp(c * self) in CH(amb), calculated via exp_list.
Args:
c (QQ): coefficient
amb (tuple, optional): enhanced profile. Defaults to None.
stop (int, optional): cut-off. Defaults to None.
Returns:
ELGTautClass: the tautological class associated to the
graded list exp_list.
F)�reduce)�exp_list�extend�psi_listrZ r[ r\ r] r )r �cre �stopZ
new_taut_list�Tr r r �exp^ s �zAdditiveGenerator.expc C s� t |�}|du r | jj}d}n | jj|� }|g}|}t d�}t d�}|du rZ| j�� d }||k r�|| jjkr�|d7 }||| 9 }| �||�}|�|| � qZ|S )at
Calculate exp(c * self) in CH(amb).
We calculate exp as a sum of powers (using self.pow, i.e. cached)
and check at each step if the power vanishes (if yes, we obviously stop).
The result is returned as a list consisting of the graded pieces.
Optionally, one may specify the cut-off degree using stop (by
default this is dim + 1).
Args:
c (QQ): coefficient
amb (tuple, optional): enhanced profile. Defaults to None.
stop (int, optional): cut-off. Defaults to None.
Returns:
list: list of ELGTautClasses
Nra r r )r r rb rc rA �ZEROr: r ) r rj re rk rb �e�f�coeffrU r r r rg s s" zAdditiveGenerator.exp_listc s� | j du r*tjj�| jd| j�|�fg�S | j�| j|�}|du rTt d�|| jf �g }t
d�t
t |�� }|D ]4� � fdd�| j � � D �}|�
|| j�||�f� qptjj�| j|�S dS )a�
Pull back self to the graph associated to deg_enh_profile.
Note that this returns an ELGTautClass as there could be several maps.
More precisely, we return the sum over the pulled back classes divided
by the number of undegeneration maps.
Args:
deg_enh_profile (tuple): enhanced profile of graph to pull back to.
Raises:
RuntimeError: raised if deg_enh_profile is not a degeneration of the
underlying graph of self.
Returns:
ELGTautClass: sum of pullbacks of self to deg_enh_profile for each
undegeneration map divided by the number of such maps.
Nr z/Pullback failed: %r is not a degeneration of %rc s i | ]\}}� | |�qS r r )r2 r ro ��leg_mapr r r4 � s
�z/AdditiveGenerator.pull_back.<locals>.<dictcomp>)r rZ r[ r\ r] r r6 �explicit_leg_mapsr rN r rH �itemsr )r Zdeg_enh_profile�leg_mapsri Z
aut_factorr7 r rr r � pull_back� s2
���
����zAdditiveGenerator.pull_backc sL �� |���j� z � ��fdd��j| D �}W n tyF i }Y n0 |S )z�
The psi classes on level l of self.
Args:
l (int): level, i.e. 0,...,codim
Returns:
dict: psi dictionary on self.level(l).smooth_LG
c s$ i | ] }� j �j| �j| �qS r )�dmp_invr rL ��EG�Lr r r r4 � s �z3AdditiveGenerator.psis_on_level.<locals>.<dictcomp>)rO � smooth_LGrK r )r r �psisr ry r �
psis_on_level� s
�
z AdditiveGenerator.psis_on_levelFc
C s | j | j�� k r6|r|r2td| | j | j�� f � dS g }t| jd �D ]b}| �|�| �|�k rptd| |f ��| � |�}|j
| � |�|||d�}|dkr� dS |� |� qHd}|D ] } || 9 }q�|�std� td� t| � td| � td | j
� td
|| j
� td� | j
| S ) a�
Evaluate self (cap with the fundamental class of self._X).
Note that this gives 0 if self is not a top-degree class.
Evaluation works by taking the product of the evaluation of each level
(i.e. evaluating, for each level, the psi monomial on this level) and
multiplying this with the stack factor.
The psi monomials on the levels are evaluated using admcycles (after
removing residue conditions).
Raises a RuntimeError if there are inconsistencies with the psi degrees
on the levels.
INPUT:
quiet: boolean (optional)
If set to true, then get no output. Defaults to False.
warnings_only: boolean (optional)
If set to true, then output warnings. Defaults to False.
admcycles_output: boolean (optional)
If set to true, prints debugging info (used when evaluating levels). Defaults to False.
OUTPUT:
the integral of self on X as a rational number.
z4Warning: %r is not of top degree: %r (instead of %r)r r z(%r is of top degree, but not on level %r)r} �quiet�
warnings_only�admcycles_outputz4----------------------------------------------------z#Contribution of Additive generator:z#Product of level-wise integrals: %rzStack factor: %rz Total: %r)r@ r rA �printrC rB rE rD rN rO �evaluater~ r rY )
r r r� r� �
level_listr r{ �valuerT rV r r r r� � sD �
�
�
zAdditiveGenerator.evaluatec s� � j j}|j}t� fdd�t� jd �D ��r>tjj|g d�S t|j �dkr�� j
j g kr�tjj |� j
d�}tj�|g�}� j
jd j}� j
jd j}tj�|d|�}tjj||| gd�} | S g }
g } t� jd �D ]B} � �| �}
� �| ��|
�}|
�|�� � | �|�|�| ��� qԈ jtj�|� }t |
�D ]\} }|� | | |�}�q2|�r�� j � � }� j j |dd �}|jj}tj�||j �}|S )
ak
Transform self into an admcycles prodtautclass on the underlying stgraph of self.
Note that this gives the pushforward to M_g,n in the sense that we multiply with
Strataclass and remove all residue conditions.
Returns:
prodtautclass: the prodtautclass of self, multiplied with the Strataclasses of
the levels and all residue conditions removed.
EXAMPLES::
sage: from admcycles.diffstrata import *
sage: X=Stratum((2,))
sage: X.additive_generator(((),0)).to_prodtautclass()
Outer graph : [2] [[1]] []
Vertex 0 :
Graph : [2] [[1]] []
Polynomial : -7/24*(kappa_1)_0 + 79/24*psi_1
<BLANKLINE>
<BLANKLINE>
Vertex 0 :
Graph : [1] [[1, 3, 4]] [(3, 4)]
Polynomial : -1/48
<BLANKLINE>
<BLANKLINE>
Vertex 0 :
Graph : [1, 1] [[3], [1, 4]] [(3, 4)]
Polynomial : -19/24
sage: from admcycles.stratarecursion import Strataclass
sage: X=GeneralisedStratum([Signature((4,-2,-2))], res_cond=[[(0,1)], [(0,2)]])
sage: (X.additive_generator(((),0)).to_prodtautclass().pushforward() - Strataclass(1, 1, [4,-2,-2], res_cond=[2])).is_zero()
True
TESTS::
sage: from admcycles import diffstrata, psiclass
sage: X = diffstrata.generalisedstratum.GeneralisedStratum(sig_list = [diffstrata.sig.Signature(tuple([8,-3,-2,-3]))], res_cond = [[(0,1)],[(0,2)]])
sage: X.psi(1).evaluate()
9
sage: v = X.ONE.to_prodtautclass().pushforward()
sage: (v*psiclass(1,1,4)).evaluate()
9
We noticed the problem that the markings of the prodtautclass of an AdditiveGenerator are usually not the standard one,
and hence its pushforward to M_g,n is not comparable to that of other AdditiveGenerator. Thus we solve this
by adding the keyword "relabel"::
sage: X=diffstrata.generalisedstratum.Stratum((4,-2))
sage: X.additive_generator(((1,),0)).to_prodtautclass(relabel=True)
Outer graph : [1, 0] [[3, 4], [1, 2, 5, 6]] [(3, 5), (4, 6)]
Vertex 0 :
Graph : [1] [[1, 2]] []
Polynomial : 1/2
Vertex 1 :
Graph : [0] [[1, 2, 3, 4]] []
Polynomial : psi_4
<BLANKLINE>
<BLANKLINE>
Vertex 0 :
Graph : [1] [[1, 2]] []
Polynomial : 1/2
Vertex 1 :
Graph : [0, 0] [[2, 3, 9], [1, 4, 12]] [(9, 12)]
Polynomial : 3
<BLANKLINE>
<BLANKLINE>
Vertex 0 :
Graph : [1] [[1, 2]] []
Polynomial : 1/2
Vertex 1 :
Graph : [0, 0] [[3, 4, 9], [1, 2, 12]] [(9, 12)]
Polynomial : -3
We fixed the problem that when the ELGTautClass arised from removing residue conditions of a level stratum has only one term, the
original algorithm would break down. We can test it::
sage: X=diffstrata.generalisedstratum.GeneralisedStratum([diffstrata.sig.Signature((0,-1,-1)),diffstrata.sig.Signature((0,-1,-1))], res_cond=[[(0,1),(1,1)]])
sage: X.additive_generator(((),0)).to_prodtautclass()
Outer graph : [0, 0] [[1, 2, 3], [4, 5, 6]] []
Vertex 0 :
Graph : [0] [[1, 2, 3]] []
Polynomial : 1
Vertex 1 :
Graph : [0] [[1, 2, 3]] []
Polynomial : 1
c 3 s | ]}� � |��� V qd S r$ )rO �zeroStratumClassr1 r% r r rM } s �z5AdditiveGenerator.to_prodtautclass.<locals>.<genexpr>r )�terms)�psir )�protautF)�tidyup)!r r �stgraph�anyrC rB rZ �
prodtautclassrH �generar �res_cond�
decstratumr � tautclass� _sig_list�sig�g�stratarecursion� Strataclassr~ rO �remove_res_condr �to_prodtautclass�verticesonlevel�internal_level_numberrY � enumerate�factor_pullback�standard_markings�relabelr� )r r� r r� Zadm_psisZ
adm_psis_tautr� r� Z
stratum_class�result�alpha�verticesr r} rl rT �ptcZstandard_legdict�newEmbLGr r% r r� s< [ �
z"AdditiveGenerator.to_prodtautclass)N)N)NN)NN)FFF)F)%�__name__�
__module__� __qualname__�__doc__r � classmethodr# r& r+ r, r/ r8 r9 r< �propertyr r? r rG rB r@ r rJ rK rE rO rD rY r^ r` r: rm rg rw r~ r� r� r r r r r sd
!
"
'* �
Ar )
�sage.structure.sage_objectr �sage.misc.cachefuncr �sage.rings.rational_fieldr �admcycles.admcyclesrZ �admcycles.stratarecursion�!admcycles.diffstrata.elgtautclass� admcycles.diffstrata.auxiliaryr r r r r r �<module> s