unlisted
ubuntu2004o
��cn, � @ sH d dl mZ d dlmZ d dlmZ d dlZd dlZG dd� de�Z dS )� )�Counter)�
SageObject)�
cached_methodNc @ s� e Zd ZdZd1dd�Zedd� �Zedd� �Zd d
� Z d d � Z
d
d� Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zdd � Zd d � Zed d � �Zd!d"� Z # #d2d$d%�Zd&d'� Zed(d)� �Zed*d+� �Zd,d-� Zd.d/� Z d0S )3� ELGTautClassaT
A Tautological class of a stratum X, i.e. a formal sum of of psi classes on
EmbeddedLevelGraphs.
This is encoded by a list of summands.
Each summand corresponds to an AdditiveGenerator with coefficient.
Thus an ELGTautClass is a list with entries tuples (coefficient, AdditiveGenerator).
These can be added, multiplied and reduced (simplified).
INPUT :
* X : GeneralisedStratum that we are on
* psi_list : list of tuples (coefficient, AdditiveGenerator) as
described above.
* reduce=True : call self.reduce() on initialisation
Tc C s || _ || _|r| �� d S d S �N)� _psi_list�_X�reduce)�self�X�psi_listr � r
�E/home/user/Introduction lectures/admcycles/diffstrata/elgtautclass.py�__init__ s
�zELGTautClass.__init__c s | � � fdd�|D �dd�S )Nc s g | ] \}}|� � |�f�qS r
)� additive_generator_from_hash)�.0�c�h�r r
r �
<listcomp>) s �z/ELGTautClass.from_hash_list.<locals>.<listcomp>F�r r
)�clsr Z hash_listr
r r �from_hash_list& s
��zELGTautClass.from_hash_listc C s | j S r )r �r
r
r
r r , s zELGTautClass.psi_listc C s d| j | jf S )Nz ELGTautClass(X=%r,psi_list=%r)�r r r r
r
r �__repr__0 s
�zELGTautClass.__repr__c C s. d| j }| jD ] \}}|d||f 7 }q|S )NzTautological class on %s
z %s * %s +
r )r
�str�coeff�psir
r
r �__str__4 s
zELGTautClass.__str__c C s@ t |tjjj�r| |�� kS z| j|jkW S ty Y dS w )NF)�
isinstance� admcycles�
diffstrata�additivegenerator�AdditiveGenerator�as_tautr �AttributeError�r
�otherr
r
r �__eq__: s � �zELGTautClass.__eq__c C sP |dkr| S z| j |j kstW S | j|j }t| j |�W S ty' t Y S w )Nr )r �NotImplementedr r r& �r
r( �new_psisr
r
r �__add__D s �zELGTautClass.__add__c C �
| � |�S r �r- r' r
r
r �__iadd__P �
zELGTautClass.__iadd__c C r. r r/ r' r
r
r �__radd__S r1 zELGTautClass.__radd__c C s d| S �N�����r
r r
r
r �__neg__V s zELGTautClass.__neg__c C s | d| S r3 r
r' r
r
r �__sub__Y s zELGTautClass.__sub__c s� d� krdS | j j� kr| S t� tjjj�r | � �� S z� j W n t y< � fdd�| jD �}t
| j |dd� Y S w | j � j ksEt S | j � | � �S )Nr c s g | ]
\}}|� |f�qS r
r
)r r r �r( r
r r k � z(ELGTautClass.__mul__.<locals>.<listcomp>Fr )
r �ONEr r! r" r# r$ r% r r& r r* � intersectionr+ r
r7 r �__mul__\ s$ �
� zELGTautClass.__mul__c C r. r )r; r' r
r
r �__rmul__r r1 zELGTautClass.__rmul__c C s0 |dkr| j jS | }td|�D ]}| | }q|S )Nr � )r r9 �range)r
�exponent�prod�_r
r
r �__pow__u s
zELGTautClass.__pow__c s2 | j r| j d d j� t� fdd�| j D ��S dS )a
Determine if all summands of self have the same degree.
Note that the empty empty tautological class (ZERO) gives True.
Returns:
bool: True if all AdditiveGenerators in self.psi_list are of same degree,
False otherwise.
r r= c 3 s � | ]
\}}|j � kV qd S r )�degree)r �_c�AG�Z first_degr
r � <genexpr>� s � z2ELGTautClass.is_equidimensional.<locals>.<genexpr>T)r rC �allr r
rF r �is_equidimensional~ s z ELGTautClass.is_equidimensionalc C s> t � }| jD ] \}}|| |7 < qdd� |�� D �| _dS )z�
Reduce self.psi_list by combining summands with the same AdditiveGenerator
and removing those with coefficient 0 or that die for dimension reasons.
c S s( g | ]\}}|d kr|� � r||f�qS )r )� dim_check)r rE r r
r
r r � s
��z'ELGTautClass.reduce.<locals>.<listcomp>N)r r �items)r
Z hash_dictr rE r
r
r r � s zELGTautClass.reduceFc
C s� |rd}g }| j D ]\}}|j|||d�}|�|| � q |sVtd� td� t|�D ] \}} td| � t| j | d � td| j | d � q+td t|� � td� t|�S )
a�
Evaluation of self, i.e. cap with fundamental class of X.
This is the sum of the evaluation of the AdditiveGenerators in psi_list
(weighted with their coefficients).
Each AdditiveGenerator is (essentially) the product of its levels,
each level is (essentially) evaluated by admcycles.
Args:
quiet (bool, optional): No output. Defaults to True.
warnings_only (bool, optional): Only warnings output. Defaults to False.
admcycles_output (bool, optional): admcycles debugging output. Defaults to False.
Returns:
QQ: integral of self on X
EXAMPLES::
sage: from admcycles.diffstrata import *
sage: X=GeneralisedStratum([Signature((0,0))])
sage: assert (X.xi^2).evaluate() == 0
sage: X=GeneralisedStratum([Signature((1,1,1,1,-6))])
sage: assert set([(X.cnb(((i,),0),((i,),0))).evaluate() for i in range(len(X.bics))]) == {-2, -1}
T)�quiet�
warnings_only�admcycles_outputz4----------------------------------------------------zIn summary: We sumz&Contribution %r from AdditiveGeneratorr= z(With coefficient %r)r zTo obtain a total of %r)r �evaluate�append�print� enumerate�sum)
r
rL rM rN ZDS_listr rE �value�i�summandr
r
r rO � s( � zELGTautClass.evaluatec C s t | j| j| gdd�S )z�
Return the i-th component of self.
Args:
i (int): index of self._psi_list
Returns:
ELGTautClass: coefficient * AdditiveGenerator at position i of self.
Fr )r r r )r
rU r
r
r �extract� s
zELGTautClass.extractc C s< g }| j D ]\}}|j|kr|�||f� qt| j|dd�S )z�
The degree d part of self.
Args:
d (int): degree
Returns:
ELGTautClass: degree d part of self
Fr )r rC rP r r )r
�dr, r rE r
r
r rC � s
�zELGTautClass.degreec sR dd� t � j�� d �D �}� jD ]\}}||j �||f� q� fdd�|D �S )z�
A list of length X.dim with the degree d part as item d
Returns:
list: list of ELGTautClasses with entry i of degree i.
c S s g | ]}g �qS r
r
)r rA r
r
r r � s z/ELGTautClass.list_by_degree.<locals>.<listcomp>r= c s g | ]
}t � j|d d��qS )Fr )r r )r �piecer r
r r � s �)r> r �dimr rC rP )r
Z deg_psi_listr rE r
r r �list_by_degree� s
�zELGTautClass.list_by_degreec C s, | j sdS t| j �dko| j d d jdkS )a*
Check if self is ZERO or a psi-product on the stratum.
Returns:
boolean: True if self has at most one summand and that is of the form
AdditiveGenerator(((), 0), psis).
EXAMPLES::
sage: from admcycles.diffstrata import *
sage: X=Stratum((2,))
sage: X.ZERO.is_pure_psi()
True
sage: X.ONE.is_pure_psi()
True
sage: X.psi(1).is_pure_psi()
True
sage: X.xi.is_pure_psi()
False
Tr= r )r
r )r �len� enh_profiler r
r
r � is_pure_psi� s ���zELGTautClass.is_pure_psic s� | j j� � jj}tjj|g d�}| jD ]d\}}|�� }i }t� jj �D ]9\}}� j
� jj | d } |j j
| }
|j j} | �|
�} | �| �}
| �� �|
�D ]\}}}|dkrWqM|||< qMq#� fdd�|j j
�� D �}|�|||�}||| 7 }q|S )a�
Transforms self into an admcycles prodtautclass on the stable graph of the smooth
graph of self._X.
Note that this is essentially the pushforward to M_g,n, i.e. we resolve residues
and multiply with the correct Strataclasses along the way.
Returns:
prodtautclass: admcycles prodtautclass corresponding to self pushed forward
to the stable graph with one vertex.
EXAMPLES::
sage: from admcycles.diffstrata import *
sage: X=Stratum((2,))
sage: X.ONE.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, 2, 3]] [(2, 3)]
Polynomial : -1/48
<BLANKLINE>
<BLANKLINE>
Vertex 0 :
Graph : [1, 1] [[2], [1, 3]] [(2, 3)]
Polynomial : -19/24
sage: (X.xi^X.dim()).evaluate() == (X.xi^X.dim()).to_prodtautclass().pushforward().evaluate()
True
)�termsr �LGc s i | ]
\}}� j | |�qS r
)�dmp_inv)r Zldeg�mp��Gr
r �
<dictcomp>L r8 z1ELGTautClass.to_prodtautclass.<locals>.<dictcomp>)r � smooth_LGr` �stgraphr! �
prodtautclassr �to_prodtautclassrR �genera�dmp�legs�_Gra �vertex� UG_vertexZUG_without_infinity�%connected_component_containing_vertexrK �partial_pushforward)r
rg �totalr rE �ptc�
vertex_map�vrA Z
mp_on_stratumZl_AGr` Zv_AGZUG_v�w�g�kind�leg_map�pfr
rc r ri s. "
�
�z ELGTautClass.to_prodtautclassN)T)TFF) �__name__�
__module__� __qualname__�__doc__r � classmethodr �propertyr r r r) r- r0 r2 r5 r6 r; r< rB r rI r rO rW rC r[ r^ ri r
r
r
r r s>
�0
r )
� collectionsr �sage.structure.sage_objectr �sage.misc.cachefuncr �&admcycles.diffstrata.additivegeneratorr! �admcycles.admcyclesr r
r
r
r �<module> s