unlisted
ubuntu2004a
��c^� � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z m
Z
ddl m Z m
Z
ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lmZmZmZ ddl m Z ddl m Z ddl m!Z! ddl"m#Z# ddl$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7 ddl8m9Z9 dd l:m;Z; e� �<� Z=G d d � d e �Z>G d d � d ee!�Z?G d!d"� d"e�Z@dS )#zL
Tautological subring of the cohomology ring of the moduli space of curves.
� N)�
cached_method)�prod)�UniqueRepresentation)�op_EQ�op_NE)�
ModuleElement�parent)�coercion_model)�Functor)�ConstructionFunctor)�Algebras)�Rings)� factorial� bernoulli� multinomial)�
Partitions)�IntegerVectors)�Algebra��ZZ)�QQ��vector)�PolynomialRing)� TermOrder��WeightedIntegerVectors)�matrix� )�_moduli_to_str�_str_to_moduli� MODULI_TL�
get_moduli� socle_degree)�
decstratum)� StableGraph)�identify_classc @ sx e Zd ZdZdWdd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd � ZdXd d �ZdYd d!�ZdZd"d#�Zd[d$d%�Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd\d0d1�Zd2d3� Zd4d5� Z d6d7� Z d]d8d9�Z d:d;� Z d^d<d=�Z d_d>d?�Z!d`d@dA�Z"dBdC� Z#dadDdE�Z$dbdFdG�Z%dHdI� Z&dcdJdK�Z'dddLdM�Z(dedNdO�Z)dfdQdR�Z*dSdT� Z+dUdV� Z,d S )g�TautologicalClassaB
An element of a tautological ring.
Internally, it is represented by a list ``terms`` of objects of type
:class:`admcycles.admcycles.decstratum`. Such element should never
be constructed directly by calling :class:`TautologicalClass`. Instead
use the parent class :class:`TautologicalRing` or dedicated functions
as in the examples below
EXAMPLES::
sage: from admcycles import *
sage: R = TautologicalRing(3,1)
sage: gamma = StableGraph([1,2],[[1,2],[3]],[(2,3)])
sage: ds1 = R(gamma, kappa=[[1],[]])
sage: ds1
Graph : [1, 2] [[1, 2], [3]] [(2, 3)]
Polynomial : (kappa_1)_0
sage: ds2 = R(gamma, kappa=[[],[1]])
sage: ds2
Graph : [1, 2] [[1, 2], [3]] [(2, 3)]
Polynomial : (kappa_1)_1
sage: t = ds1 + ds2
sage: (t - R(gamma) * R.kappa(1)).is_zero()
True
Constructing a tautological class from dedicated functions::
sage: psiclass(1, 2, 1) # psi_1 on M_{2,1}
Graph : [2] [[1]] []
Polynomial : psi_1
Tc C sX t �| |� t|ttf�r�i | _|D ]�}t|t�s6t�|j� � rHt
d��|j� |j �rXq$|rp|�
|j � |�� |j| jv r�| j|j j|j7 _| j|j s�| j|j= q$|| j|j< q$n�t|t��rP|�rHi | _|�� D ]h\}}||jkr�t
�|� |j ��rq�|�
|j � |�� |r�|| jv �r:| j| |7 < q�|| j|< q�n|| _nt�dS )a
INPUT:
- parent : a class:`TautologicalRing`
- terms : a list of class:`~admcycles.admcycles.decstratum`
- clean: boolean (default ``True``)
whether to apply ``dimension_filter`` and ``consolidate`` on the input
zDmutable stable graph in a decstratum when building TautologicalClassN)r �__init__�
isinstance�tuple�list�_termsr$ � TypeError�gamma�
is_mutable�
ValueError�vanishes�_moduli�dimension_filter� consolidate�poly�dict�items)�selfr �terms�clean�tr. �term� r= �?/home/user/Introduction lectures/admcycles/tautological_ring.pyr( N sD
zTautologicalClass.__init__c C s$ | � � }|�|dd� | j�� D ��S )Nc S s i | ]\}}||� � �qS r= ��copy��.0�gr; r= r= r> �
<dictcomp>� � z*TautologicalClass.copy.<locals>.<dictcomp>)r �
element_classr, r7 �r8 �Pr= r= r> r@ s zTautologicalClass.copyc C s4 t | j�D ]$}| j| �� | j| s
| j|= q
d S �N)r+ r, r3 �r8 rC r= r= r> r3 � s
z"TautologicalClass.dimension_filterc s( � j s
dS d�� fdd�t� j �D ��S )N�0z
c 3 s | ]}t � j| �V qd S rI )�reprr, �rB rC �r8 r= r> � <genexpr>� rE z+TautologicalClass._repr_.<locals>.<genexpr>)r, �join�sortedrN r= rN r> �_repr_� s zTautologicalClass._repr_c s> ddl m}m} � js |d�S t� fdd�t� j�D �|� �S )uU
Return unicode art for the tautological class.
EXAMPLES::
sage: from admcycles import *
sage: D = DR_cycle(1,(2,-2))
sage: unicode_art(D)
Graph :
<BLANKLINE>
╭──╮
│1 │
╰┬┬╯
12
<BLANKLINE>
Polynomial : 2*ψ₁ + 2*ψ₂
Graph :
╭╮
45
╭┴┴╮
│0 │
╰┬┬╯
12
<BLANKLINE>
Polynomial : -1/24
r )� unicode_art�
UnicodeArtrK c 3 s | ]}� j | �� V qd S rI )r, �
_unicode_art_rM rN r= r> rO � rE z2TautologicalClass._unicode_art_.<locals>.<genexpr>)�sage.typeset.unicode_artrS rT r, r rQ )r8 rS rT r= rN r> rU � s z TautologicalClass._unicode_art_c C s | j S rI )r, rN r= r= r> �is_empty� s zTautologicalClass.is_emptyc C s | � � �� S )a,
Return whether this element is nilpotent.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 1)
sage: R.one().is_nilpotent()
False
sage: R.psi(1).is_nilpotent()
True
)�constant_coefficient� is_nilpotentrN r= r= r> rY � s
z TautologicalClass.is_nilpotentc C s | � � �� S )a
Return whether this element is a unit.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 1)
sage: R.one().is_unit()
True
sage: R.psi(1).is_unit()
False
)rX �is_unitrN r= r= r> rZ � s
zTautologicalClass.is_unitc C s8 zddl m} W n ty. ddlm} Y n0 || �S )aH
Return the inverse of this element.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(0, 5)
sage: (R.one() + R.psi(1)).inverse_of_unit()
Graph : [0] [[1, 2, 3, 4, 5]] []
Polynomial : 1 - psi_1 + psi_1^2
r )�inverse_of_unitr )Zsage.rings.polynomial.miscr[ � ImportError�misc)r8 r[ r= r= r> r[ � s
z!TautologicalClass.inverse_of_unitc C sB | � � }i }| j�� D ] \}}|�|�}|r|||< q|�||�S )aL
Return the homogeneous component of degree ``d``.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 2)
sage: f = (1 - 2 * R.psi(1) + 3 * R.psi(2)**2)**2
sage: f.degree_part(0)
Graph : [1] [[1, 2]] []
Polynomial : 1
sage: f.degree_part(1)
Graph : [1] [[1, 2]] []
Polynomial : -4*psi_1
sage: f.degree_part(2)
Graph : [1] [[1, 2]] []
Polynomial : 6*psi_2^2 + 4*psi_1^2
)r r, r7 � degree_partrF )r8 �drH � new_termsrC r< r= r= r> r^ � s
z TautologicalClass.degree_partc C s | � � S )a�
Return the coefficient in degree zero as an element in the base ring.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 1)
sage: (1/3 - R.psi(1) + R.kappa(2)).constant_coefficient()
1/3
sage: A.<x, y> = QQ[]
sage: R = TautologicalRing(2, 1, base_ring=A)
sage: f = (1 - x * R.psi(1)) * (1/3 + y * R.kappa(2))
sage: f.constant_coefficient()
1/3
TESTS::
sage: from admcycles import TautologicalRing, StableGraph
sage: R = TautologicalRing(3,2)
sage: Gamma = StableGraph([3],[[2,1]],[]); Gamma
[3] [[2, 1]] []
sage: a = R.one() + R(Gamma); a
Graph : [3] [[1, 2]] []
Polynomial : 1
<BLANKLINE>
Graph : [3] [[2, 1]] []
Polynomial : 1
sage: a.constant_coefficient()
2
)�
fund_evaluaterN r= r= r> rX s z&TautologicalClass.constant_coefficientc C sB | � � }i }| j�� D ] \}}|�|�}|r|||< q|�||�S )a~
Return the class where we drop components of degree above ``dmax``.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 2)
sage: f = (1 - 2 * R.psi(1) + 3 * R.psi(2)**2)**2
sage: f.degree_cap(1)
Graph : [1] [[1, 2]] []
Polynomial : 1 - 4*psi_1
)r r, r7 �
degree_caprF )r8 �dmaxrH r` rC r< r= r= r> rb # s
z TautologicalClass.degree_capc
O s� i }| j �� D ]�\}}|jdd�}|jj}|jj}d}|t|�k r�|| j|i |��||< || sx|�|� |�|� q6|d7 }q6|r|||< q| � � } | �
| |�S )a�
Perform substitution on coefficients.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: A.<a1, a2> = PolynomialRing(QQ,2)
sage: R = TautologicalRing(2, 2, base_ring=A)
sage: t = a1 * R.psi(1) + a2 * R.psi(2)
sage: t
Graph : [2] [[1, 2]] []
Polynomial : a1*psi_1 + a2*psi_2
sage: t.subs({a2: 1 - a1})
Graph : [2] [[1, 2]] []
Polynomial : a1*psi_1 + (-a1 + 1)*psi_2
sage: t
Graph : [2] [[1, 2]] []
Polynomial : a1*psi_1 + a2*psi_2
sage: t = (a1 - a2) * R.psi(1) + (a1 + a2) * R.psi(2)
sage: t.subs({a1: a2})
Graph : [2] [[1, 2]] []
Polynomial : 2*a2*psi_2
sage: t.subs({a1: 0, a2: 0})
0
sage: t
Graph : [2] [[1, 2]] []
Polynomial : (a1 - a2)*psi_1 + (a1 + a2)*psi_2
F��mutabler r ) r, r7 r@ r5 �coeff�monom�len�subs�popr rF )
r8 �args�kwdsr` rC r< �coeffsrg �irH r= r= r> ri 8 s
zTautologicalClass.subsNc C sb | � � r | S | �� }|dur.|�| �|�|�S |�� }| �� D ]}||�| �|�|�7 }q>|S dS )aa
Return representation of self as a tautclass formed by a linear combination of
the preferred tautological basis.
If ``r`` is given, only take degree r part.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(0, 4)
sage: t = 7 + R.psi(1) + 3 * R.psi(2) - R.psi(3)
sage: t.FZsimplify()
Graph : [0] [[1, 2, 3, 4]] []
Polynomial : 7 + 3*(kappa_1)_0
sage: t.FZsimplify(r=0)
Graph : [0] [[1, 2, 3, 4]] []
Polynomial : 7
N)rW r �from_basis_vector� basis_vector�zero� degree_list)r8 �r�R�resultr= r= r> �
FZsimplifyj s z TautologicalClass.FZsimplifyc C s� | � � }|d us|d urjddlm} |dd� |d ur@||jksR|d urj||jkrjtd�|||j|j���ddlm} ||� � dd� | j
� � D ��S ) Nr �� deprecation�m zNthe arguments 'g' and 'n' of TautologicalClass.toprodtautclass are deprecated.z.invalid (g,n) (got ({},{}) instead of ({},{})))�
prodtautclassc S s g | ]}|� � g�qS r= r? �rB r; r= r= r> �
<listcomp>� rE z5TautologicalClass.toprodtautclass.<locals>.<listcomp>) r �
supersededrx �_g�_nr0 �format� admcyclesrz �
trivial_graphr, �values)r8 rC �nrH rx rz r= r= r> �toprodtautclass� s
$ z!TautologicalClass.toprodtautclassc C s� | � � }|dus |dus |dur6ddlm} |dd� |durF|g}n| �� }| �� r^| �� S |�� }|D ]}||�| �|�|�7 }qj|j | _ | S )a�
Simplifies self by combining terms with same tautological generator, returns self.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 1)
sage: t = R.psi(1) + 11*R.psi(1)
sage: t
Graph : [2] [[1]] []
Polynomial : 12*psi_1
sage: t.simplify()
Graph : [2] [[1]] []
Polynomial : 12*psi_1
Nr rw ry zFthe arguments 'g, n, r' of TautologicalClass.simplify are deprecated.)
r r} rx rr rW r@ rq � from_vectorr r, ) r8 rC r� rs rH rx �Dru r_ r= r= r> �simplify� s
zTautologicalClass.simplifyc C s� | � � }|dus|durjddlm} |dd� |dur@||jksR|durj||jkrjtd�|||j|j���| �� rz| �� S |dur�|� | �
|�|�S | � � | S )zj
Return a simplified version of self by combining terms with same tautological generator.
Nr rw ry zIthe arguments 'g' and 'n' of TautologicalClass.simplified are deprecated.z,invalid g,n (got ({},{}) instead of ({},{}))) r r} rx r~ r r0 r� rW r@ r� r r� )r8 rC r� rs rH rx r= r= r> �
simplified� s
$z TautologicalClass.simplifiedc C s8 | � � r| �� S | �� }|j|dd� | j�� D �dd�S )Nc S s i | ]\}}|| �qS r= r= �rB rC r< r= r= r> rD � rE z-TautologicalClass.__neg__.<locals>.<dictcomp>F�r: )rW r@ r rF r, r7 rG r= r= r> �__neg__� s zTautologicalClass.__neg__c C s� | � � r|�� S |� � r | �� S | �� }dd� | j�� D �}|j�� D ]<\}}||v rz|| j|j7 _|| s�||= qF|||< qF|j||dd�S )a8
TESTS::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 1)
sage: R(1) + 1
Graph : [1] [[1]] []
Polynomial : 2
sage: 1 + R(1)
Graph : [1] [[1]] []
Polynomial : 2
c S s i | ]\}}||� � �qS r= r? rA r= r= r> rD � rE z+TautologicalClass._add_.<locals>.<dictcomp>Fr� )rW r@ r r, r7 r5 rF )r8 �otherrH r` rC r< r= r= r> �_add_� s
zTautologicalClass._add_c sd | � � }t � �| �� u s J �� �� r,|�� S � �� r<| �� S � fdd�| j�� D �}|j||dd�S )a�
Scalar multiplication by ``other``.
TESTS::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 2)
sage: -3/5 * R.psi(1)
Graph : [2] [[1, 2]] []
Polynomial : -3/5*psi_1
sage: 0 * R.psi(1) == 1 * R.zero() == R.zero()
True
sage: assert (0 * R.psi(1)).parent() is R
sage: assert (1 * R.zero()).parent() is R
c s i | ]\}}|� | �qS r= r= r� �r� r= r> rD rE z,TautologicalClass._lmul_.<locals>.<dictcomp>Fr� ) r � base_ring�is_zerorq �is_oner@ r, r7 rF )r8 r� rH r` r= r� r> �_lmul_� s zTautologicalClass._lmul_c
C sN | � � s|� � r | �� �� S | �� }|jr�|jd |jkr�dd� t|j�D �}dd� t|j�D �}| j|dd�|j|dd� j|dd�S i }| j�� D ]�}|j�� D ]v}|� ||�j�
� D ]^\}} |� |j �r�q�| j
|j d� | jjdd� | r�||v �r|| j| j7 _q�| ||< q�q�q�t|�D ]}|| �s&||= �q&|j||dd �S )
a�
TESTS::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 2)
sage: R.psi(1) * R.psi(2)
Graph : [2] [[1, 2]] []
Polynomial : psi_1*psi_2
sage: R.generators(1)[3] * R.generators(2)[23]
Graph : [0, 1, 1] [[1, 2, 4], [5, 6], [7]] [(4, 5), (6, 7)]
Polynomial : (kappa_1)_2
sage: (R.zero() * R.one()) == (R.one() * R.zero()) == R.zero()
True
sage: R.one() * R.one() == R.one()
True
Multiplication with non-standard markings::
sage: from admcycles import StableGraph
sage: R2 = TautologicalRing(1, [4, 7])
sage: g2 = StableGraph([0], [[1,2,4,7]], [(1,2)])
sage: R2(g2) * (1 + R2.psi(4)) * (1 + R2.psi(7))
Graph : [0] [[1, 2, 4, 7]] [(1, 2)]
Polynomial : 1 + psi_7 + psi_4
�����c S s i | ]\}}||d �qS �r r= �rB rn �jr= r= r> rD , rE z+TautologicalClass._mul_.<locals>.<dictcomp>c S s i | ]\}}|d |�qS r� r= r� r= r= r> rD - rE F��inplace��moduli)�forcer� )rW r rq � _markingsr � enumerate� rename_legsr, r� �multiplyr7 r1 r2 r3 r5 r4 r+ rF )
r8 r� rH Z
dic_to_stdZ dic_from_stdr` �t1�t2rC r< r= r= r> �_mul_ s. &
zTautologicalClass._mul_c C sz | � d�rtd��| �� }|�� }|�� }|dkr6|S || }| }td|d �D ]$}|| }|tdt|�f�| 7 }qP|S )a�
Return the exponential of this tautological class.
The exponential is defined as ``exp(x) = 1 + x + 1/2*x^2 + ... ``.
It is well defined as long as ``x`` has no degree zero term.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 2)
sage: R.psi(1).exp()
Graph : [1] [[1, 2]] []
Polynomial : 1 + psi_1 + 1/2*psi_1^2
TESTS::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(0, 3)
sage: R.zero().exp() == R.one()
True
r znon-zero degree zero term� r )r r0 r �oner# �ranger r )r8 rH �frc ru �y�kr= r= r> �expB s
zTautologicalClass.expc s� | � � }� du rt|j � � dkr*td��|jt� �kr\t|j|j|�� � d�}|| �� � S t
� fdd�| j � � D �|�� �
� �S )a�
Computes integral against the fundamental class of the corresponding moduli space,
e.g. the degree of the zero-cycle part of the tautological class (for moduli='st').
For non-standard moduli, this computes the socle-evaluation, which is given by
the integral against
* lambda_g for moduli='ct'
* lambda_g * lambda_{g-1} for moduli='rt' (and moduli='sm' for n=0)
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 1)
sage: R.kappa(1).evaluate()
1/24
Some non-standard moduli::
sage: from admcycles import *
sage: R = TautologicalRing(2,1,moduli='ct')
sage: R.kappa(2).evaluate()
7/5760
sage: (kappaclass(2,2,1)*lambdaclass(2,2,1)).evaluate()
7/5760
sage: R.kappa(2).evaluate(moduli='st') # wrong degree
0
TESTS::
sage: R = TautologicalRing(2,1,moduli='ct')
sage: Rst = TautologicalRing(2,1)
sage: L = lambdaclass(2,2,1)
sage: all((Rst(t)*L).evaluate() == t.evaluate() for t in R.generators(2))
True
sage: R = TautologicalRing(2,2,moduli='rt')
sage: Rst = TautologicalRing(2,2)
sage: LL = Rst.lambdaclass(2)*Rst.lambdaclass(1)
sage: all((Rst(t)*LL).evaluate() == t.evaluate() for t in R.generators(2))
True
N�tlz=no well-defined socle evaluation for space of treelike curves)r� r� c 3 s | ]}|j � d �V qdS )r� N��evaluater{ r� r= r> rO � rE z-TautologicalClass.evaluate.<locals>.<genexpr>)r r r2 r0 r" �TautologicalRingr~ r� r� r� �sumr, r� rq �r8 r� rH rt r= r� r> r� g s *
zTautologicalClass.evaluatec C s | � d�d S )a�
Computes degree zero part of the class as multiple of the fundamental class.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 1)
sage: t = R.psi(1)
sage: s = t.forgetful_pushforward([1])
sage: s
Graph : [2] [[]] []
Polynomial : 2
sage: s.fund_evaluate()
2
r r rN r= r= r> ra � s z TautologicalClass.fund_evaluatec s^ |t kr|tkrtd��t��� �}|�� �� � t|�}t� �fdd�|D ��}||t kkS )a�
Implementation of comparisons (``==`` and ``!=``).
TESTS::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2,2)
sage: R.zero() == R.zero()
True
sage: R.zero() == R.psi(1)
False
sage: R.psi(1) == R.zero()
False
sage: R.psi(1) == R.psi(1)
True
sage: R.psi(1) == R.psi(2)
False
sage: R.zero() != R.zero()
False
sage: R.zero() != R.psi(1)
True
sage: R.psi(1) != R.zero()
True
sage: R.psi(1) != R.psi(1)
False
sage: R.psi(1) != R.psi(2)
True
sage: R = TautologicalRing(1,1)
sage: A = R(1) + R.psi(1) - R.kappa(1)
sage: A == R.zero()
False
sage: A == R.one()
True
Z incomparablec 3 s6 | ].}�� |�� � |�kp,��|�� �|�kV qd S rI )r rp �rB r_ �r� r8 r= r> rO � rE z.TautologicalClass._richcmp_.<locals>.<genexpr>)r r r- �setrr �updaterQ �all)r8 r� �opr� �equalr= r� r> � _richcmp_� s $ zTautologicalClass._richcmp_c s t � fdd�� �� D �� S )z�
TESTS::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 1)
sage: bool(R.psi(1))
True
sage: bool(R.zero())
False
c 3 s* | ]"}� � |��� p � �|��� V qd S rI )r r� rp r� rN r= r> rO � rE z-TautologicalClass.__bool__.<locals>.<genexpr>)r� rr rN r= rN r> �__bool__� s zTautologicalClass.__bool__c C sn | � � }t||j�}||jkr8td�t| t|j ���||jkrdt|j|j||� � d�}|| � S | S dS )a�
Return whether this class is a known tautological relation (using
Pixton's implementation of the generalized Faber-Zagier relations).
If optional argument `moduli` is given, it checks the vanishing on
an open subset of the current moduli of stable curves.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(3, 0)
sage: diff = R.kappa(1) - 12 * R.lambdaclass(1)
sage: diff.is_zero()
False
sage: S = TautologicalRing(3, 0, moduli='sm')
sage: S(diff).is_zero()
True
sage: diff.is_zero(moduli='sm')
True
sage: S(diff).is_zero(moduli='st')
Traceback (most recent call last):
...
ValueError: moduli='st' is larger than the moduli 'sm' of the parent
�8moduli={!r} is larger than the moduli {!r} of the parent�r� N)
r r" r2 r0 r� r r� r~ r� r� r� r= r= r> r� � s
�
zTautologicalClass.is_zeroc C s t tdd� | j�� D ���S )aK
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 3)
sage: R.psi(1).degree_list()
[1]
sage: (1 + R.psi(1)**2).degree_list()
[0, 2]
sage: ((1 + R.psi(1))**2).degree_list()
[0, 1, 2]
c s s& | ] }|� � D ]\}}}|V qqd S rI )�gnr_list)rB r; rC r� r_ r= r= r> rO rE z0TautologicalClass.degree_list.<locals>.<genexpr>)rQ r� r, r� rN r= r= r> rr s
z TautologicalClass.degree_listc s� | � � }�du r| S t�tj�r:t��}|dk r�td��nPt�ttf�r�tt���}t ��t t
|j d |j | d ��kr�td� �|���|dkr�| S t
|j|j | |j|�� d�� t� �fdd�| j�� D �� �� �S ) a�
Return the pullback of this tautological class under a forgetful map
`\bar M_{g, n'} --> \bar M_{g,n}`
INPUT:
forget : list of integers
legs that are forgotten by the map forgetful map
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 2)
sage: b = R.psi(2).forgetful_pullback([3])
sage: b
Graph : [1] [[1, 2, 3]] []
Polynomial : psi_2
<BLANKLINE>
Graph : [1, 0] [[1, 4], [2, 3, 5]] [(4, 5)]
Polynomial : -1
sage: b.parent()
TautologicalRing(g=1, n=3, moduli='st') over Rational Field
Nr z forget can only be non-negativer z=can only forget the highest markings, got forget={} inside {}�r� r� c 3 s | ]}� � � |����V qd S rI )rF Zforgetful_pullback_list)rB �c�rt �forgetr= r> rO I rE z7TautologicalClass.forgetful_pullback.<locals>.<genexpr>)r r) �numbers�Integralr r0 r* r+ rh r� r� r r� r� r~ r2 r� r� r, r� rq )r8 r� rH r� r= r� r> �forgetful_pullback s
& z$TautologicalClass.forgetful_pullbackc sF | � � }� du r| �� S t� tj�rdt� �}|dk s>||jkrFtd��|dkrR| S |j| d� � n�t� t t
f�r�tt � ��}t � �� t
t � �d �D ]*}� | � |d kr�td�� | ���q�� D ] }||jvr�td�|���q�ntd��|dkr�| S � fdd �|jD �}t|j||j|�� d
�}|�|� fd d �| j�� D ��S ) a�
Return the pushforward of a given tautological class under a forgetful
map `\bar M_{g,n} \to \bar M_{g,n'}`.
INPUT:
forget : list of integers
legs that are forgotten by the map forgetful map
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 3)
sage: s1 = R.psi(3)^2
sage: s1.forgetful_pushforward([3])
Graph : [1] [[1, 2]] []
Polynomial : (kappa_1)_0
sage: s1.forgetful_pushforward([2,3])
Graph : [1] [[1]] []
Polynomial : 1
sage: R = TautologicalRing(1, [2, 5, 6])
sage: s1 = R.psi(5)^2
sage: s1.forgetful_pushforward([5])
Graph : [1] [[2, 6]] []
Polynomial : (kappa_1)_0
sage: s1.forgetful_pushforward([5]).parent()
TautologicalRing(g=1, n=(2, 6), moduli='st') over Rational Field
sage: R = TautologicalRing(2, 2)
sage: gens1 = R.generators(1)
sage: t = gens1[1] + 2*gens1[3]
sage: t.forgetful_pushforward([2])
Graph : [2] [[1]] []
Polynomial : 3
sage: t.forgetful_pushforward([2]).parent()
TautologicalRing(g=2, n=1, moduli='st') over Rational Field
TESTS::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(1, [2, 4]).psi(4).forgetful_pushforward([5])
Traceback (most recent call last):
...
ValueError: invalid marking 5 in forget
sage: TautologicalRing(1, [2, 4]).psi(4).forgetful_pushforward(2)
Traceback (most recent call last):
...
ValueError: unstable pair (g,n) = (1, 0)
sage: TautologicalRing(1, [2, 4]).psi(4).forgetful_pushforward(3)
Traceback (most recent call last):
...
ValueError: forget must be between 0 and the number of markings
Nr z3forget must be between 0 and the number of markingsr z multiple marking {} in forgetz invalid marking {} in forgetzinvalid input forgetc s g | ]}|� vr|�qS r= r= �rB rn �r� r= r> r| � rE z;TautologicalClass.forgetful_pushforward.<locals>.<listcomp>r� c s g | ]}|� � ��qS r= )�forgetful_pushforward�rB r< r� r= r> r| � rE )r r@ r) r� r� r r r0 r� r* r+ rh rQ r� r� r- r� r~ r2 r� rF r, r� )r8 r� rH r� rn � new_markingsrt r= r� r> r� K s2 8
z'TautologicalClass.forgetful_pushforwardc s� |dur ddl m} |dd� | �� }� fdd�|jD �}tt|�� ��}||jkr�|rjtd�|j|���t |j
||j |� � d �}n|}|r�t
| j�� �} | j�� | D ] }
|
j� d
d � |
| j|
j< q�| S |� fd d
�| j�� D ��S dS )a�
Rename the legs according to the dictionary ``dic``.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 2)
sage: cl = R.psi(1) * R.psi(2)
sage: cl.rename_legs({2:5}, inplace=False)
Graph : [1] [[1, 5]] []
Polynomial : psi_1*psi_5
sage: parent(cl.rename_legs({2:5}, inplace=False))
TautologicalRing(g=1, n=(1, 5), moduli='st') over Rational Field
Note that inplace operation is forbidden if the relabellings of the markings
is not a bijection::
sage: _ = cl.rename_legs({2:5}, inplace=True)
Traceback (most recent call last):
...
ValueError: invalid inplace operation: change of markings (1, 2) -> (1, 5)
TESTS::
sage: from admcycles import *
sage: G1 = StableGraph([1,1],[[1,2,4],[3,5]],[(4,5)])
sage: A = G1.to_tautological_class()
sage: _ = A.rename_legs({1:3,3:1})
sage: list(A._terms)
[[1, 1] [[2, 3, 4], [1, 5]] [(4, 5)]]
sage: for g, t in A._terms.items():
....: assert g == t.gamma
Nr rw ry zYthe rename keyword in TautologicalClass.rename_legs is deprecated. Please set rename=Nonec s i | ]}|� � ||��qS r= )�getr� ��dicr= r> rD � rE z1TautologicalClass.rename_legs.<locals>.<dictcomp>z6invalid inplace operation: change of markings {} -> {}r� Tr� c s g | ]}|j � d d��qS )Fr� )r� r{ r� r= r> r| � rE z1TautologicalClass.rename_legs.<locals>.<listcomp>)r} rx r r� r* rQ r� r0 r� r� r~ r2 r� r+ r, �clearr� r. ) r8 r� �renamer� rx rH Z clean_dicr� rt �lr; r= r� r> r� � s* #
�
z TautologicalClass.rename_legsc C s | j |�� dd�S )a�
Applies the permutation ``g`` to the markings.
INPUT:
g: permutation in the symmetric group `S_n`
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 2)
sage: G = SymmetricGroup(2)
sage: g = G('(1,2)')
sage: R.psi(1).permutation_action(g) == R.psi(2)
True
Fr� )r� r6 rJ r= r= r> �permutation_action� s z$TautologicalClass.permutation_actionc C sV | j s
dS | �� j}|du r0ddlm} ||�}|�� D ]}| �|�| kr8 dS q8dS )a}
Return whether this tautological class is symmetric under the action of G.
INPUT:
G: (optional) subgroup of symmetric group
if no argument is given take Sn
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 2)
sage: (R.psi(1) * R.psi(2)).is_symmetric()
True
sage: R.psi(1).is_symmetric() # psi(1) = psi(2) in H^*(M_{1,2})
True
sage: R = TautologicalRing(2, 2)
sage: R.psi(1).is_symmetric()
False
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 3)
sage: G = PermutationGroup([(1,2)])
sage: a = R.psi(1) + R.psi(2)
sage: a.is_symmetric(G)
True
sage: a.is_symmetric()
False
TNr ��SymmetricGroupF)r, r r �$sage.groups.perm_gps.permgroup_namedr� �gensr� )r8 �GZnum_legr� rC r= r= r> � is_symmetric� s
z TautologicalClass.is_symmetricc sX � � � }|�� }� js|S |du r8ddlm} ||j�}|�� fdd�|D ��|�� S )a�
Return the symmetrization of self under the action of ``G``.
INPUT:
G: (optional) subgroup of symmetric group
if no argument is given take Sn
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 2)
sage: R.psi(1).symmetrize()
Graph : [2] [[1, 2]] []
Polynomial : 1/2*psi_1 + 1/2*psi_2
Nr r� c 3 s | ]}� � |�V qd S rI )r� rM rN r= r> rO 7 rE z/TautologicalClass.symmetrize.<locals>.<genexpr>)r rq r, r� r� r r� � cardinality)r8 r� rH �resr� r= rN r> �
symmetrize s
z TautologicalClass.symmetrizec C s@ | � � }|jr"|jd |jkr"| S | jdd� t|j�D �dd�S )a�
Return an isomorphic tautological class where standard markings `{1, 2, ..., n}`
are used.
EXAMPLES::
sage: from admcycles import StableGraph, TautologicalRing
sage: R = TautologicalRing(4, [4,7])
sage: g = StableGraph([3], [[4,7,1,2]], [(1,2)])
sage: a = R(g, psi={4:1}) + R(g, psi={7:2}) + R(g, kappa=[[0,0,1]])
sage: a.standard_markings()
Graph : [3] [[1, 2, 4, 7]] [(4, 7)]
Polynomial : psi_1 + psi_2^2 + (kappa_3)_0
sage: a.standard_markings().parent()
TautologicalRing(g=4, n=2, moduli='st') over Rational Field
r� c S s i | ]\}}||d �qS r� r= r� r= r= r> rD M rE z7TautologicalClass.standard_markings.<locals>.<dictcomp>Fr� )r r� r r� r� rG r= r= r> �standard_markings9 s z#TautologicalClass.standard_markingsc s� | � � } | �� � | �� r8�du r(td��tt� ����S �du rd| �� �t��dkr\td���d �ddl m
� t � ��fdd�| j �
� D ��S ) a�
EXAMPLES:
We consider the special case of the moduli space ``g=1`` and ``n=2``::
sage: from admcycles import TautologicalRing, StableGraph
sage: R = TautologicalRing(1, 2)
Degree zero::
sage: R(2/3).vector()
(2/3)
sage: R.from_vector([2/3], 0)
Graph : [1] [[1, 2]] []
Polynomial : 2/3
Degree one examples::
sage: kappa1 = R.kappa(1)
sage: kappa1.vector()
(1, 0, 0, 0, 0)
sage: R.from_vector([1,0,0,0,0], 1)
Graph : [1] [[1, 2]] []
Polynomial : (kappa_1)_0
sage: psi1 = R.psi(1)
sage: psi1.vector()
(0, 1, 0, 0, 0)
sage: gamma2 = StableGraph([0], [[1,2,3,4]], [(3,4)])
sage: R(gamma2).vector()
(0, 0, 0, 0, 1)
Some degree two examples::
sage: kappa2 = R.kappa(2)
sage: kappa2.vector()
(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
sage: (kappa1*psi1).vector()
(0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
sage: R(gamma2, kappa=[[1],[]]).vector()
(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0)
sage: gamma3 = StableGraph([0,0], [[1,2,3],[4,5,6]], [(3,4),(5,6)])
sage: R(gamma3).vector()
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0)
Empty class::
sage: R(0).vector(1)
(0, 0, 0, 0, 0)
Non-standard markings::
sage: R = TautologicalRing(1, [4, 7])
sage: R.psi(4).vector()
(0, 1, 0, 0, 0)
sage: R.from_vector((0, 1, 0, 0, 0), 1)
Graph : [1] [[4, 7]] []
Polynomial : psi_4
sage: TautologicalRing(1, 1).zero().vector()
Traceback (most recent call last):
...
ValueError: specify degree to obtain vector of empty class
TESTS:
Non-standard moduli::
sage: R = TautologicalRing(2,2,moduli='ct')
sage: all(u.vector() == vector(QQ,23,{i:1}) for i,u in enumerate(R.generators(2)))
True
Nz.specify degree to obtain vector of empty classr �5for non-homogeneous term, set r to the desired degreer )�converttoTautvectc 3 s$ | ] }�|� j � j�� j�V qd S rI )r~ r r2 r� �rH r� rs r= r> rO � rE z+TautologicalClass.vector.<locals>.<genexpr>)r� r rW r0 r r �num_gensrr rh r� r� r� r, r� �r8 rs r= r� r> r O s I zTautologicalClass.vectorc C s� | � � } | �� }t||j�}||jkr@td�t| t|j ���|du rl| �� }t|�dkrdtd��|d }||jkr�| �� }t |j
|j ||� � d�}|| ��
|�S | �� }ddlm} || �|�|j
|j|t|j �S )ak
Return a vector expressing the class in the basis of the tautological ring.
The corresponding basis is obtained from
:meth:~`TautologicalRing.basis`.
EXAMPLES::
sage: from admcycles import TautologicalRing, StableGraph
sage: R = TautologicalRing(2, 1)
sage: gamma = StableGraph([1],[[1,2,3]],[(2,3)])
sage: b = R(gamma)
sage: b.basis_vector()
(10, -10, -14)
sage: R.from_basis_vector((10, -10, -14), 1) == b
True
sage: Rct = TautologicalRing(2, 1, moduli='ct')
sage: Rct(b).basis_vector(1)
(0, 0)
sage: Rct(b).basis_vector(1,moduli='tl')
Traceback (most recent call last):
...
ValueError: moduli='tl' is larger than the moduli 'ct' of the parent
sage: R = TautologicalRing(2, 2)
sage: c = R.psi(1)**2
sage: for moduli in ('st', 'tl', 'ct', 'rt'):
....: Rmod = TautologicalRing(2, 2, moduli=moduli)
....: print(Rmod(c).basis_vector())
(0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0)
(5/6, -1/6, 1/3, 0, 0)
(1)
sage: Rsm = TautologicalRing(2, 2, moduli='sm')
sage: Rsm(c).basis_vector(2)
()
Compatibility test with non-standard markings::
sage: R1 = TautologicalRing(1, 2)
sage: g1 = StableGraph([0], [[1,2,3,4]], [(3,4)])
sage: a1 = R1(g1, psi={1:1}) + R1(g1, psi={2:2}) + R1(g1, kappa=[[0,0,1]])
sage: R2 = TautologicalRing(1, [4,7])
sage: g2 = StableGraph([0], [[4,7,1,2]], [(1,2)])
sage: a2 = R2(g2, psi={4:1}) + R2(g2, psi={7:2}) + R2(g2, kappa=[[0,0,1]])
sage: a1.basis_vector(0) == a2.basis_vector(0)
True
sage: a1.basis_vector(1) == a2.basis_vector(1)
True
sage: a1.basis_vector(2) == a2.basis_vector(2)
True
sage: a1.basis_vector(3) == a2.basis_vector(3)
True
r� Nr r� r r� )�Tautvecttobasis)r� r r" r2 r0 r� r rr rh r� r~ r� r� rp r� r� r r )r8 rs r� rH rt r� r= r= r> rp � s& ;
�
z TautologicalClass.basis_vectorc C sT ddl m} |dd� | �� }|d ur0||jksB|d urJ||jkrJtd��| �|�S )Nr rw ry z4toTautvect is deprecated. Please use vector instead.� invalid g,n)r} rx r r~ r r0 r )r8 rC r� rs rx rH r= r= r> �
toTautvect� s
$z TautologicalClass.toTautvect�stc C s� ddl m} |dd� | �� }|d ur0||jksB|d urJ||jkrJtd��t| |jkrxt|j|j||� � d�}|| �} | �
|�S )Nr rw ry z;toTautbasis is deprecated. Please use basis_vector instead.r� r� ) r} rx r r~ r r0 r r2 r� r� rp )r8 rC r� rs r� rx rH r= r= r> � toTautbasis s
$z TautologicalClass.toTautbasisc s4 ddl m} |dd� | �� � � fdd�| �� D �S )Nr rw ry z7gnr_list is deprecated. Please use degree_list instead.c s g | ]}� j � j|f�qS r= )r~ r r� �rH r= r> r| rE z.TautologicalClass.gnr_list.<locals>.<listcomp>)r} rx r rr )r8 rx r= r� r> r� s
zTautologicalClass.gnr_listc O s2 ddl m} |dd� | j|i |��}|j| _| S )Nr rw ry z2coeff_subs is deprecated. Please use subs instead.)r} rx ri r, )r8 rk rl rx ru r= r= r> �
coeff_subs s
z TautologicalClass.coeff_subs)T)N)NN)NNN)NNN)N)N)N)N)NT)N)N)N)NN)NNN)NNNr� )-�__name__�
__module__� __qualname__�__doc__r( r@ r3 rR rU rW rY rZ r[ r^ rX rb ri rv r� r� r� r� r� r� r� r� r� ra r� r� r� rr r� r� r� r� r� r� r� r rp r� r� r� r� r= r= r= r> r' , sT !
1 "2
!
"
7%
50
%
+
Z
<
*
X
V
r' c s� e Zd ZdZeZe� fdd��Zdd� Zdd� Z e
dd � �Z d
d � Z d d
� Z
dd� Zdd� Zdd� Zdd� Zdd� Ze
dd� �Zdd� Zd d � Zd d � Zd d!� Zd"d#� ZeZd$d%� Zd&d'� Zdcd)d*�Z d+d,� Z e Z d-d.� Z e Z d/d0� Z!d1d2� Z"d3d4� Z#ddd6d7�Z$d8d9� Z%d:d;� Z&d<d=� Z'ded>d?�Z(dfd@dA�Z)dgdBdC�Z*dhdEdF�Z+dGdH� Z,didIdJ�Z-djdLdM�Z.dNdO� Z/e
dkdPdQ��Z0dldRdS�Z1dTdU� Z2dmdVdW�Z3dndXdY�Z4dZd[� Z5dod^d_�Z6e7Z7dpdadb�Z8� Z9S )qr� a�
The tautological subgring of the (even degree) cohomology of the moduli space of curves.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(2)
TautologicalRing(g=2, n=0, moduli='st') over Rational Field
sage: TautologicalRing(1, 2)
TautologicalRing(g=1, n=2, moduli='st') over Rational Field
sage: TautologicalRing(1, 1, 'tl')
TautologicalRing(g=1, n=1, moduli='tl') over Rational Field
sage: from admcycles.moduli import MODULI_ST
sage: TautologicalRing(0, 5, MODULI_ST, QQ)
TautologicalRing(g=0, n=5, moduli='st') over Rational Field
Since tautological rings are commutative algebras one can use them as basic building
blocks of further algebraic constructors in SageMath::
sage: R = TautologicalRing(2, 0)
sage: Rxy.<x,y> = PolynomialRing(R, ['x', 'y'])
sage: Rxy
Multivariate Polynomial Ring in x, y over TautologicalRing(g=2, n=0, moduli='st') over Rational Field
sage: R.kappa(1) * x + R.kappa(2) * y # TODO: horrible display
(Graph : [2] [[]] []
Polynomial : (kappa_1)_0)*x + (Graph : [2] [[]] []
Polynomial : (kappa_2)_0)*y
sage: V = FreeModule(R, 2)
sage: V
Ambient free module of rank 2 over TautologicalRing(g=2, n=0, moduli='st') over Rational Field
sage: V((R.kappa(1), R.kappa(2))) # TODO: horrible display
(Graph : [2] [[]] []
Polynomial : (kappa_1)_0, Graph : [2] [[]] []
Polynomial : (kappa_2)_0)
TESTS::
sage: from admcycles import TautologicalRing
sage: TestSuite(TautologicalRing(1, 1)).run()
sage: TestSuite(TautologicalRing(1, [3])).run()
sage: TestSuite(TautologicalRing(1, 1, 'tl', QQ['x,y'])).run()
sage: cm = get_coercion_model()
sage: cm.get_action(QQ, TautologicalRing(2,0))
Left scalar multiplication by Rational Field on TautologicalRing(g=2, n=0, moduli='st') over Rational Field
Test for https://gitlab.com/modulispaces/admcycles/-/issues/70::
sage: from admcycles import TautologicalRing
sage: W = TautologicalRing(1,1)
sage: V = PolynomialRing(W, 'x,y')
sage: V.one()
Graph : [1] [[1]] []
Polynomial : 1
Test for https://gitlab.com/modulispaces/admcycles/-/issues/79::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(2, 0).gens()
(...)
c sZ |� dd �}|� dd �}|� dd �}|� dd �}|rJtd�t|�� ����t|�dkrn|d urftd��|d }t|�d kr�|d ur�td
��|d }t|�d kr�|d ur�td ��|d }t|�d
kr�|d ur�td��|d }t|�d
kr�td�|���t|�}t|tj ��r|dk �r td��t
|�}|d u �r<t
� � }d� n�t|t tf��r�dd� t
|�D �� t� �}� �� � �r�� d dk�r�td��t� fdd�t|d �D ���r�td��t � �� nDt|tj ��r�|dk �r�td��t
|�}t td|d ��� ntd��|d u �rt}n|tv�r(td�|���||fdv �rFtd �||���t� �| |� ||�S ) NrC r� r� r� zunknown arguments {}r zgenus g specified twicer r� z)number of marked points n specified twice� zmoduli specified twice� zbase_ring specified twicez+too many arguments for TautologicalRing: {}z g must be a non-negative integerr= c S s g | ] }t |��qS r= r r� r= r= r> r| � rE z2TautologicalRing.__classcall__.<locals>.<listcomp>z"markings must be positive integersc 3 s" | ]}� | � |d kV qdS �r Nr= r� ��markingsr= r> rO � rE z1TautologicalRing.__classcall__.<locals>.<genexpr>zrepeated markingz n must be a non-negative integerz
invalid inputz*base_ring (={}) must be a commutative ring))r r )r r )r r� )r r z unstable pair (g,n) = ({}, {}))rj r0 r� r+ �keysrh r" r) r� r� r rq r* rQ �sort�anyr� r- r �_CommutativeRings�super�
__classcall__)�clsrk rl rC r� r� r� �� __class__r� r> r� b sj
z TautologicalRing.__classcall__c C s< t j| |t|��� �� d� || _|| _t|�| _|| _ dS )z�
INPUT:
g : integer
genus
markings : tuple of distinct positive integers
list of markings
moduli : integer
code for the moduli
base_ring : ring
base ring
)�categoryN)
r r( r � Commutative�FiniteDimensionalr~ r� rh r r2 )r8 rC r� r� r� r= r= r> r( � s
zTautologicalRing.__init__c C s dS )NTr= rN r= r= r> �is_commutative� s z TautologicalRing.is_commutativec C s4 | j r| j d | jkr| S t| j| j| j| �� d�S )a�
Return an equivalent moduli space with the standard markings `{1, 2, \ldots, n}`.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, [4, 7])
sage: R
TautologicalRing(g=2, n=(4, 7), moduli='st') over Rational Field
sage: R.standard_markings()
TautologicalRing(g=2, n=2, moduli='st') over Rational Field
r� r� )r� r r� r~ r2 r� rN r= r= r> r� � s z"TautologicalRing.standard_markingsc C s | � � dko| �� �� S )a{
Return ``False`` unless the tautological ring is supported in degree 0 and the base ring
is an integral domain.
This uses that any element of positive order is torsion.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(1,3,moduli='ct').socle_degree()
2
sage: TautologicalRing(1,3,moduli='ct').is_integral_domain()
False
sage: TautologicalRing(0,3).is_integral_domain()
True
sage: TautologicalRing(0,3,base_ring=ZZ.quotient(8)).is_integral_domain()
False
r )r# r� �is_integral_domainrN r= r= r> r� � s z#TautologicalRing.is_integral_domainc C s | � � dko| �� �� S )aQ
Return ``False`` unless the tautological ring is supported in degree 0 and the base ring
is a field.
This uses that any element of positive order is torsion.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(1,3,moduli='ct').socle_degree()
2
sage: TautologicalRing(1,3,moduli='ct').is_field()
False
sage: TautologicalRing(0,3).is_field()
True
sage: TautologicalRing(0,3,base_ring=ZZ.quotient(5)).is_field()
True
r )r# r� �is_fieldrN r= r= r> r� � s zTautologicalRing.is_fieldc C s | � � dko| �� �� S )a-
Return ``False`` unless the tautological ring is supported in degree 0 and the base ring
is a prime field.
This uses that any element of positive order is torsion.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(1,3,moduli='ct', base_ring=GF(5)).is_prime_field()
False
sage: TautologicalRing(0,3,base_ring=QQ).is_prime_field()
True
sage: TautologicalRing(0,3,base_ring=GF(5)).is_prime_field()
True
r )r# r� �is_prime_fieldrN r= r= r> r� � s z TautologicalRing.is_prime_fieldc C sH t |t�rD| j|jkrD| j|jkrD| j|jkrD| �� �|�� �rDdS dS )a�
TESTS::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(1, 1, base_ring=QQ['x','y']).has_coerce_map_from(TautologicalRing(1, 1, base_ring=QQ))
True
sage: M11st = TautologicalRing(1, 1, moduli='st')
sage: M11ct = TautologicalRing(1, 1, moduli='ct')
sage: M11st.has_coerce_map_from(M11ct)
False
sage: M11ct.has_coerce_map_from(M11st)
True
TN)r) r� r~ r� r2 r� �has_coerce_map_from�r8 r� r= r= r> �_coerce_map_from_ s
�
�
��z"TautologicalRing._coerce_map_from_c C s t | j| j| j�| �� fS )a�
Return a functorial construction (when applied to a base ring).
This function is mostly intended to make the tautological ring behave nicely
with Sage ecosystem.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 1)
sage: QQ['x'].gen() * R.psi(1) # indirect doctest
Graph : [1] [[1]] []
Polynomial : x*psi_1
sage: A = TautologicalRing(3, 2, moduli='st', base_ring=QQ['x'])
sage: B = TautologicalRing(3, 2, moduli='tl', base_ring=QQ)
sage: A.psi(1) + B.psi(2) # indirect doctest
Graph : [3] [[1, 2]] []
Polynomial : psi_1 + psi_2
sage: (A.psi(1) + B.psi(2)).parent()
TautologicalRing(g=3, n=2, moduli='tl') over Univariate Polynomial Ring in x over Rational Field
)�TautologicalRingFunctorr~ r� r2 r� rN r= r= r> � construction s z TautologicalRing.constructionc C sZ | j ttd| jd ��kr8d�| j| jt| j | �� �S d�| j| j t| j | �� �S d S )Nr z1TautologicalRing(g={}, n={}, moduli={!r}) over {}) r� r* r� r r� r~ r r2 r� rN r= r= r> rR 8 s zTautologicalRing._repr_c C s t | j| j| j�S )a�
Return the socle degree of this tautological ring.
The socle degree is the maximal degree whose corresponding graded
component is non-empty. It is currently not implemented for the
moduli of tree like curves.
The formulas were computed in:
- [GrVa01]_, [GrVa05]_ and [FaPa05]_ for compact type
- [Lo95]_, [Fa99]_ and [FaPa00]_ for rational tail
- [Lo95]_, [Io02]_ for smooth curves
EXAMPLES::
sage: from admcycles import TautologicalRing
We display below the socle degree for various `(g, n)` for the moduli of
smooth curves, rational tails, compact types and stable curves::
sage: for (g,n) in [(0,3), (0,4), (0, 5), (1,1), (1,2), (2,0), (2, 1)]:
....: dims = []
....: for moduli in ['sm', 'rt', 'ct', 'st']:
....: R = TautologicalRing(g, n, moduli=moduli)
....: dims.append(R.socle_degree())
....: print("g={} n={}: {}".format(g, n, " ".join(map(str, dims))))
g=0 n=3: 0 0 0 0
g=0 n=4: 0 1 1 1
g=0 n=5: 0 2 2 2
g=1 n=1: 0 0 0 1
g=1 n=2: 0 1 1 2
g=2 n=0: 0 0 1 3
g=2 n=1: 1 1 2 4
The socle degree is overestimated for tree-like::
sage: R = TautologicalRing(2, moduli='tl')
sage: R.socle_degree()
3
sage: R.kappa(3).is_zero() # generator for \bar M_2
True
)r# r~ r r2 rN r= r= r> r# > s +z TautologicalRing.socle_degreec C s t | jgt| j�gg dd�S )z�
Return the stable graph corresponding to the full stratum.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(2, [1, 3, 4]).trivial_graph()
[2] [[1, 3, 4]] []
Frd )r% r~ r+ r� rN r= r= r> r� k s z TautologicalRing.trivial_graphc C s | � � S rI )r� rN r= r= r> � _an_element_x s z TautologicalRing._an_element_c sz � fdd�� � � �� D �}|dd� |dd� }|�� �� � � jr\|�� �� jd �� � jdkrv|�� �d�� |S )aJ
Return some elements in this tautological ring.
This is mostly used for sage test system.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: _ = TautologicalRing(0, [4, 5, 7]).some_elements()
sage: _ = TautologicalRing(2, [4, 7]).some_elements()
c s g | ] }� |��qS r= r= �rB �srN r= r> r| � rE z2TautologicalRing.some_elements.<locals>.<listcomp>Nr� �����r r )r� �
some_elements�append� irreducible_boundary_divisorr� �psir~ �kappa)r8 Z base_elts�eltsr= rN r> r { s
z TautologicalRing.some_elementsc C s | � | g �S )z�
Return the zero element.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(0, 4).zero()
0
)rF rN r= r= r> rq � s
zTautologicalRing.zeroc C sv | � � }|D ]d}| �|�}|j�� D ]J\}}||jv r`|j| j|j7 _|j| sn|j|= q$|�� |j|< q$q |S )a(
Return the sum of ``classes``.
EXAMPLES::
sage: from admcycles import TautologicalRing, psiclass
sage: R = TautologicalRing(1, 2)
sage: R.sum([R(1),R(1),R(0),R(1)])
Graph : [1] [[1, 2]] []
Polynomial : 3
sage: R.sum([psiclass(1,1,2),psiclass(2,1,2)]) == psiclass(1,1,2) + psiclass(2,1,2)
True
sage: R.sum([1,1])
Graph : [1] [[1, 2]] []
Polynomial : 2
Your elements must be coercible into the tautological ring::
sage: R.sum(['a', 'b', 'c'])
Traceback (most recent call last):
...
TypeError: no canonical coercion from <... 'str'> to TautologicalRing(g=1, n=2, moduli='st') over Rational Field
)rq �coercer, r7 r5 r@ )r8 �classesru r; rC r< r= r= r> r� � s
zTautologicalRing.sumc C s | | � � �S )a�
Return the fundamental class as a cohomology class.
The fundamental class is the unit of the ring.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 1)
sage: R.fundamental_class()
Graph : [2] [[1]] []
Polynomial : 1
sage: R.fundamental_class() ** 2 == R.fundamental_class()
True
�r� rN r= r= r> �fundamental_class� s z"TautologicalRing.fundamental_classc C s | | � � |did�S )a�
Return the class `\psi_i` on `\bar M_{g,n}`.
Alternatively, you could use the function :func:`~admcycles.admcycles.psiclass`.
INPUT:
i : integer
the leg number associated to the psi class
EXAMPLES::
sage: from admcycles import TautologicalRing, StableGraph
sage: R = TautologicalRing(2, 3)
sage: R.psi(2)
Graph : [2] [[1, 2, 3]] []
Polynomial : psi_2
sage: R.psi(3)
Graph : [2] [[1, 2, 3]] []
Polynomial : psi_3
sage: R = TautologicalRing(3, 2)
sage: R.psi(1)
Graph : [3] [[1, 2]] []
Polynomial : psi_1
TESTS::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(3, 2)
sage: R.psi(3)
Traceback (most recent call last):
...
ValueError: unknown marking 3 for psi
r �r r )r8 rn r= r= r> r � s &zTautologicalRing.psic C sZ |dkr$d| j d | j | �� S |dk r4| �� S | | �� dg|d dg gd�S dS )a�
Return the (Arbarello-Cornalba) kappa-class `\kappa_a` on `\bar M_{g,n}` defined by
`\kappa_a= \pi_*(\psi_{n+1}^{a+1})`
where `pi` is the morphism `\bar M_{g,n+1} \to \bar M_{g,n}`.
INPUT:
a : integer
the degree a of the kappa class
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(3, 1)
sage: R.kappa(2)
Graph : [3] [[1]] []
Polynomial : (kappa_2)_0
sage: R = TautologicalRing(3, 2)
sage: R.kappa(1)
Graph : [3] [[1, 2]] []
Polynomial : (kappa_1)_0
r r� r )r N)r~ r r� rq r� )r8 �ar= r= r> r s
zTautologicalRing.kappaTc C s� | j }| j}||ks |dk r$| �� S |dkr�|r�|dkr@| �� S |dkr~ttd|d ��}tdd| jd�}|j|dd�� |�S ttd|d ��}t|d| jd�}|j|dd�� |�S | �
|| j �S )a�
Return the tautological class `\lambda_d` on `\bar M_{g,n}`.
The `\lambda_d` class is defined as the d-th Chern class
`\lambda_d = c_d(E)`
of the Hodge bundle `E`. The result is represented as a sum of stable
graphs with kappa and psi classes.
INPUT:
d : integer
the degree
pull : boolean (optional, default to ``True``)
whether the class is computed as pullback from `\bar M_{g}`
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 0)
sage: R.lambdaclass(1)
Graph : [2] [[]] []
Polynomial : 1/12*(kappa_1)_0
<BLANKLINE>
Graph : [1] [[2, 3]] [(2, 3)]
Polynomial : 1/24
<BLANKLINE>
Graph : [1, 1] [[2], [3]] [(2, 3)]
Polynomial : 1/24
sage: R = TautologicalRing(1, 1)
sage: R.lambdaclass(1)
Graph : [1] [[1]] []
Polynomial : 1/12*(kappa_1)_0 - 1/12*psi_1
<BLANKLINE>
Graph : [0] [[3, 4, 1]] [(3, 4)]
Polynomial : 1/24
TESTS::
sage: from admcycles import lambdaclass
sage: inputs = [(0,0,4), (1,1,3), (1,2,1), (2,2,1), (3,2,1), (-1,2,1), (2,3,2)]
sage: for d,g,n in inputs:
....: R = TautologicalRing(g, n)
....: assert (R.lambdaclass(d) - R.lambdaclass(d,pull=False)).is_zero()
Check for https://gitlab.com/modulispaces/admcycles/issues/58::
sage: R = TautologicalRing(4,0)
sage: L = R.lambdaclass(4)
sage: L == R.double_ramification_cycle(())
True
sage: L.basis_vector()
(-229/4, 28/3, 55/24, -13/12, 1/24, 0, 0, 0, 0, 0, 0, 0, -1/2, 1/6, 1, -1/3, -1/3, 2/3, 2/3, -4/3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -4/3, 1/3, -5/3, 20/3, 16/9, -4/3, 2/9, 1/6, 0, 0, 0, 0, 0, 0, 0, 0, 0)
r r r� r� F)�pull) r~ r rq r r+ r� r� r2 � lambdaclassr� �chern_character_to_class�hodge_chern_character)r8 r_ r rC r� Znewmarksrt r= r= r> r $ s : z TautologicalRing.lambdaclassc C sl | j dkr| �� S | j }| jr(| jd nd}t|d gt| j�|d |d g g|d |d fg�}| |�S )a<
Return the pushforward of the fundamental class under the irreducible
boundary gluing map `\bar M_{g-1,n+2} \to \bar M_{g,n}`.
EXAMPLES::
sage: from admcycles import *
sage: R = TautologicalRing(2, 5)
sage: R.irreducible_boundary_divisor()
Graph : [1] [[1, 2, 3, 4, 5, 6, 7]] [(6, 7)]
Polynomial : 1
sage: R = TautologicalRing(3, 0)
sage: R.irreducible_boundary_divisor()
Graph : [2] [[1, 2]] [(1, 2)]
Polynomial : 1
r r� r r� )r~ rq r� r% r+ )r8 rC �lastr� r= r= r> r
q s
8z-TautologicalRing.irreducible_boundary_divisorc C sr | j }| jr| jd nd}t||| gt|�|d g tt| j�t|� �|d g g|d |d fg�}| |�S )a�
Return the pushforward of the fundamental class under the boundary
gluing map `\bar M_{h,A} \times \bar M_{g-h,{1,...,n} \ A} \to \bar M_{g,n}`.
INPUT:
h : integer
genus of the first vertex
A : list
list of markings on the first vertex
EXAMPLES::
sage: from admcycles import *
sage: R = TautologicalRing(2, 5)
sage: R.separable_boundary_divisor(1, (1,3,4))
Graph : [1, 1] [[1, 3, 4, 6], [2, 5, 7]] [(6, 7)]
Polynomial : 1
sage: R = TautologicalRing(3, 3)
sage: R.separable_boundary_divisor(1, (2,))
Graph : [1, 2] [[2, 4], [1, 3, 5]] [(4, 5)]
Polynomial : 1
sage: R = TautologicalRing(2, [4, 6])
sage: R.separable_boundary_divisor(1, (6,))
Graph : [1, 1] [[6, 7], [4, 8]] [(7, 8)]
Polynomial : 1
r� r r� )r~ r� r% r+ rQ r� )r8 �h�ArC r r� r= r= r> �separable_boundary_divisor� s &���z+TautologicalRing.separable_boundary_divisorc sh �j r"�j d t�j �kr"td���j}�j�|dkr>��� S ddlm} ||�d�}|�d�}t � �� � dkr||��
� S � d dks�� dk r���� S ddlm � t � ��fdd �t
� �D ��}t � ��fd
d �t
� �D ������ �t � �fd d �t
d�d �D �� }|td�d �||d � 7 }|t ��fd
d �|D ��7 }|�� t� d �t� d � | S )a�
Return the chern character `ch_d(E)` of the Hodge bundle `E` on `\bar
M_{g,n}`.
This function implements the formula from [Mu83]_.
INPUT:
d : integer
The degree of the Chern character.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 2)
sage: R.hodge_chern_character(1)
Graph : [1] [[1, 2]] []
Polynomial : 1/12*(kappa_1)_0 - 1/12*psi_1 - 1/12*psi_2
<BLANKLINE>
Graph : [0] [[1, 2, 3, 4]] [(3, 4)]
Polynomial : 1/24
<BLANKLINE>
Graph : [0, 1] [[1, 2, 3], [4]] [(3, 4)]
Polynomial : 1/12
r� z<hodge_chern_character unsupported with non-standard markingsr r )� list_stratar� )�psiclc 3 sB | ]:}d | ��d d�| ��d d�� d | V qdS �r� r r� Nr= r� �r_ r� r r= r> rO � rE z9TautologicalRing.hodge_chern_character.<locals>.<genexpr>c 3 sB | ]:}d | ��d d�| ��d d�� d | V qdS r r= r� r r= r> rO � rE c 3 s | ]}�� |�� V qd S rI r r� )r_ r8 r= r> rO � rE �r5 c 3 s* | ]"}t d |�� f��|� d� V qdS )r r N)r �automorphism_number)rB �ind)�psipsisum_twovertr8 r= r> rO � rE )r� rh �NotImplementedErrorr~ r rq r� r rj r r r r� r� r r r3 r r )r8 r_ rC r �bdriesZirrbdryZpsipsisum_onevertZcontribr= )r_ r� r r# r8 r> r � s,
, z&TautologicalRing.hodge_chern_characterc s~ t �t�r(�fdd�td|d �D �� n �fdd�td|d �D �� t� fdd�t|�D ��}|dkrr|| �� S |j|d�S ) a
Return the Chern class associated to the Chern character.
INPUT:
t : integer
degree of the output Chern class
char : tautological class or a function
Chern character, either represented as a (mixed-degree) tautological class or as
a function m -> ch_m
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 1)
sage: R.chern_character_to_class(1, R.hodge_chern_character)
Graph : [1] [[1]] []
Polynomial : 1/12*(kappa_1)_0 - 1/12*psi_1
<BLANKLINE>
Graph : [0] [[3, 4, 1]] [(3, 4)]
Polynomial : 1/24
Note that the output of generalized_hodge_chern takes the form of a chern character::
sage: from admcycles import *
sage: from admcycles.GRRcomp import *
sage: g=2;n=2;l=0;d=[1,-1];a=[[1,[1],-1]]
sage: chern_char_to_class(1,generalized_hodge_chern(l,d,a,1,g,n)) # known bug
Graph : [2] [[1, 2]] []
Polynomial : 1/12*(kappa_1^1 )_0
<BLANKLINE>
Graph : [2] [[1, 2]] []
Polynomial : (-13/12)*psi_1^1
<BLANKLINE>
Graph : [2] [[1, 2]] []
Polynomial : (-1/12)*psi_2^1
<BLANKLINE>
Graph : [0, 2] [[1, 2, 4], [5]] [(4, 5)]
Polynomial : 1/12*
<BLANKLINE>
Graph : [1, 1] [[4], [1, 2, 5]] [(4, 5)]
Polynomial : 1/12*
<BLANKLINE>
Graph : [1, 1] [[2, 4], [1, 5]] [(4, 5)]
Polynomial : 13/12*
<BLANKLINE>
Graph : [1] [[4, 5, 1, 2]] [(4, 5)]
Polynomial : 1/24*
c s0 g | ](}d |d t |d � � j|d� �qS )r� r �rs )r r� r ��charr= r> r| ) rE z=TautologicalRing.chern_character_to_class.<locals>.<listcomp>r c s, g | ]$}d |d t |d � � |� �qS )r� r )r r r' r= r> r| + rE c 3 s< | ]4}t |�� �tt|�� t� fd d�|D �� V qdS )c 3 s | ]}� |d V qdS r� r= )rB r� ��argr= r> rO - rE zFTautologicalRing.chern_character_to_class.<locals>.<genexpr>.<genexpr>N)r �to_expr rh r r r) r= r> rO - rE z<TautologicalRing.chern_character_to_class.<locals>.<genexpr>r r& )r) r' r� r� r r r� )r8 r; r( r� r= )r* r( r> r � s 2
z)TautologicalRing.chern_character_to_classc C sl |� � | jks |�� | jkr<td�|� � |�� | j| j���tt|�� ��}|| j krhtd�|| j ���d S )Nz;invalid stable graph (has g={}, n={} instead of g={}, n={})z4invalid stable graph (has markings={} instead of {}))
rC r~ r� r r0 r� r* rQ �
list_markingsr� )r8 Zstgr� r= r= r> �_check_stable_graph2 s �
z$TautologicalRing._check_stable_graphNc sL t � t�rN� �� }|j| jks*|j| jkr2td��| �| dd� � j�� D ��S � sZ| � � S t � t
�r�| � � � � � | j
�r�| � � S |dur�t |t�s�td��|D ]2�t� �fdd�t� �� �D ��s�td�����q�t� |||d �}| �| |g�S t � ttf��r:� D ]&}t |t��s td
��| � |j� �q| �| � �S td �� ���dS ) a�
TESTS::
sage: from admcycles import TautologicalRing, StableGraph
sage: R = TautologicalRing(2,1)
sage: R(2/3)
Graph : [2] [[1]] []
Polynomial : 2/3
From a stable graph with decorations::
sage: g = StableGraph([1], [[1,2,3]], [(2,3)])
sage: R(g)
Graph : [1] [[1, 2, 3]] [(2, 3)]
Polynomial : 1
A stable graph outside of the open set defines by the moduli gives zero::
sage: Rct = TautologicalRing(2, 1, moduli='ct')
sage: Rct(g)
0
From a sequence of decorated strata::
sage: from admcycles.admcycles import decstratum
sage: gg = StableGraph([2], [[1]], [])
sage: arg = [decstratum(g), decstratum(gg, kappa=[[1]])]
sage: R(arg)
Graph : [2] [[1]] []
Polynomial : (kappa_1)_0
<BLANKLINE>
Graph : [1] [[1, 2, 3]] [(2, 3)]
Polynomial : 1
Empty argument::
sage: from admcycles import TautologicalRing
sage: TautologicalRing(1, 1)([])
0
zincompatible moduli spacesc S s i | ]\}}||� � �qS r= r? r� r= r= r> rD g rE z:TautologicalRing._element_constructor_.<locals>.<dictcomp>Nzpsi must be a dictionaryc 3 s | ]}�� j | v V qd S rI )�_legs)rB �v�r* rn r= r> rO r rE z9TautologicalRing._element_constructor_.<locals>.<genexpr>zunknown marking {} for psi)r r r5 z must be a sequence of decstrataz unknown argument of type arg={})r) r' r r~ r r0 rF r, r7 rq r% r- r1 r2 r6 r� r� � num_vertsr� r$ r* r+ r- r. r$ )r8 r* r r r5 rH �decr< r= r0 r> �_element_constructor_: s4 )
z&TautologicalRing._element_constructor_c
C sP ddl m} ddlm} |j| j|ttd| jd ��t | j
dd�d�}g }t |�t |�krbt d��t
|�}|�� �� }zt�| |�}W n( ty� t| j| j| j
|d�}Y n0 tt |��D ]6} || s�q�||| �}
|
j|| 9 _|�|
� q�| j�r@| jd | jk�r@d
d � t| j�D �} |�� } | �| |�j| d d
�S |�||�S dS )ax
Return the tautological class associated to the vector ``v`` and degree ``r`` on this tautological ring.
See also :meth:`~TautlogicalRing.generators` and :meth:`~TautologicalRing.from_basis_vector`.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 2)
sage: R.from_vector((0, -1, 0, 1, 0), 1)
Graph : [1] [[1, 2]] []
Polynomial : -psi_1
<BLANKLINE>
Graph : [0, 1] [[1, 2, 4], [5]] [(4, 5)]
Polynomial : 1
sage: R = TautologicalRing(1, [4, 7])
sage: R.from_vector((0, -1, 0, 1, 0), 1)
Graph : [1] [[4, 7]] []
Polynomial : -psi_4
<BLANKLINE>
Graph : [0, 1] [[1, 4, 7], [5]] [(1, 5)]
Polynomial : 1
This also works with non-standard moduli::
sage: R = TautologicalRing(2,0,moduli='ct')
sage: R.generators(1)
[Graph : [2] [[]] []
Polynomial : (kappa_1)_0,
Graph : [1, 1] [[2], [3]] [(2, 3)]
Polynomial : 1]
sage: R.from_vector((1,2),1)
Graph : [2] [[]] []
Polynomial : (kappa_1)_0
<BLANKLINE>
Graph : [1, 1] [[2], [3]] [(2, 3)]
Polynomial : 2
TESTS::
sage: R = TautologicalRing(2,0)
sage: x = polygen(ZZ)
sage: v = vector((x,0,0,0,0,0,0,0))
sage: R.from_vector(v, 2).parent().base_ring()
Univariate Polynomial Ring in x over Rational Field
r ��Graphtodecstratum��DRT��DRpy�Z moduli_typezinput v has wrong lengthr� r� c S s i | ]\}}|d |�qS r� r= r� r= r= r> rD � rE z0TautologicalRing.from_vector.<locals>.<dictcomp>Fr� N)r� r5 � r7 �
all_stratar~ r* r� r r" r2 rh r0 r r r� r �
common_parentr- r� r5 r r� r� r� rF r� )
r8 r/ rs r5 r7 �strata�stratmod�BR�TRrn � currstratr� rt r= r= r> r� � s2 0 � z TautologicalRing.from_vectorc C sT |dk s|| � � krdS | jtkr*td��ddlm} t|| j| j|t | j d��S )a�
INPUT:
r : integer
the degree
EXAMPLES::
sage: from admcycles import *
sage: R = TautologicalRing(2, 1)
sage: [R.dimension(r) for r in range(5)]
[1, 3, 5, 3, 1]
sage: R = TautologicalRing(2, 1, moduli='ct')
sage: [R.dimension(r) for r in range(5)]
[1, 2, 1, 0, 0]
r z;dimension not implemented for the moduli of treelike curvesr ��generating_indicesr� )
r# r2 r! r$ r� rD rh r~ r r )r8 rs rD r= r= r> � dimension� s
zTautologicalRing.dimensionc C sT | j tkrtd��ddlm}m} ddlm} || j| j |t
| j d�}|j | j|t t
d| j d ��t| j dd�d�}g }t|�t|�kr�d d
lm} | d �t|�t|��t� t
t|��D ]:}
||
s�q�||||
�} | j||
9 _|�| � q�| j�rD| jd | j k�rDd
d� t| j�D �} | �� }
|
�|
|�j| dd�S | �| |�S dS )a�
Return the tautological class of degree ``r`` corresponding to the
vector ``v`` expressing the coefficients in the basis.
See also :meth:`~TautologicalRing.basis` and :meth:`~TautologicalRing.from_vector`.
INPUT:
v : vector
r : degree
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 1)
sage: R.from_basis_vector((1,0,-2), 1)
Graph : [2] [[1]] []
Polynomial : (kappa_1)_0
<BLANKLINE>
Graph : [1, 1] [[3], [1, 4]] [(3, 4)]
Polynomial : -2
sage: R = TautologicalRing(2, [3])
sage: R.from_basis_vector((1,0,-2), 1)
Graph : [2] [[3]] []
Polynomial : (kappa_1)_0
<BLANKLINE>
Graph : [1, 1] [[1], [3, 4]] [(1, 4)]
Polynomial : -2
TESTS::
sage: for mo in ['st', 'ct', 'rt', 'sm']:
....: R = TautologicalRing(2,2,moduli=mo)
....: for a in R.generators(2):
....: assert a == R.from_basis_vector(a.basis_vector(),2)
z<from_basis not implemented for the moduli of treelike curvesr )r5 rD r6 r� Tr8 r: r )�warnz1vector v has wrong length {}; should have been {}r� c S s i | ]\}}|d |�qS r� r= r� r= r= r> rD # rE z6TautologicalRing.from_basis_vector.<locals>.<dictcomp>Fr� N)r2 r! r$ r� r5 rD r; r7 r~ r r r< r* r� r" rh �warningsrF r� �DeprecationWarningr5 r r� r� r� rF r� )r8 r/ rs r5 rD r7 Zgenindr> r? rF rn rB r� rt r= r= r> ro � s. '
� z"TautologicalRing.from_basis_vectorc C s: |du r6g }t | �� d �D ]}|�| �|�� q |S t|�}|dk sR|| �� krVg S ddlm} ddlm} g }| j r�| j d | j
kr�|| j |t t d| j
d ��t
| jdd�d �D ] }|�| �| ||�g�� q�nb|| j |t t d| j
d ��t
| jdd�d �D ]4}|�| �| ||��d
d � t| j �D ��g�� �q |S ) aZ
INPUT:
r : integer (optional)
the degree. If provided, only returns the generators of a given degree.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2,0)
sage: R.generators(1)
[Graph : [2] [[]] []
Polynomial : (kappa_1)_0,
Graph : [1, 1] [[2], [3]] [(2, 3)]
Polynomial : 1,
Graph : [1] [[2, 3]] [(2, 3)]
Polynomial : 1]
sage: R = TautologicalRing(2,0,moduli='ct')
sage: R.generators(1)
[Graph : [2] [[]] []
Polynomial : (kappa_1)_0,
Graph : [1, 1] [[2], [3]] [(2, 3)]
Polynomial : 1]
sage: R = TautologicalRing(2,0,moduli='sm')
sage: R.generators(1)
[]
TESTS::
sage: R = TautologicalRing(1, 2)
sage: for v in R.generators(0): print(v.vector())
(1)
sage: for v in R.generators(1): print(v.vector())
(1, 0, 0, 0, 0)
(0, 1, 0, 0, 0)
(0, 0, 1, 0, 0)
(0, 0, 0, 1, 0)
(0, 0, 0, 0, 1)
sage: for v in R.generators(2): print(v.vector())
(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
Test compatibility with nonstandard markings::
sage: R = TautologicalRing(1,[2,4])
sage: R.generators(1)
[Graph : [1] [[2, 4]] []
Polynomial : (kappa_1)_0, Graph : [1] [[2, 4]] []
Polynomial : psi_2, Graph : [1] [[2, 4]] []
Polynomial : psi_4, Graph : [0, 1] [[1, 2, 4], [5]] [(1, 5)]
Polynomial : 1, Graph : [0] [[1, 2, 4, 5]] [(1, 5)]
Polynomial : 1]
Nr r )r< r4 r� Tr8 r: c S s i | ]\}}|d |�qS r� r= r� r= r= r> rD rE z/TautologicalRing.generators.<locals>.<dictcomp>)r� r# �extend�
generatorsr r7 r< r� r5 r� r r~ r* r" r2 r rF r� r� )r8 rs ru r< r5 r� �stratumr= r= r> rJ * s" C 0 02zTautologicalRing.generatorsc C s t | �|��S )aR
Return a tuple whose entries are module generators for this tautological ring.
INPUT:
r: integer (optional)
If provided, return generators in the given degree only.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2,0)
sage: R.gens(1)
(Graph : [2] [[]] []
Polynomial : (kappa_1)_0,
Graph : [1, 1] [[2], [3]] [(2, 3)]
Polynomial : 1,
Graph : [1] [[2, 3]] [(2, 3)]
Polynomial : 1)
)r* rJ r� r= r= r> r� � s zTautologicalRing.gensc s� |du r*t � fdd�t� �� d �D ��S t|�}|dk sF|� �� krNt�� S z
� j}W n* ty� dg� �� d }� _Y n0 ddlm} || du r�t|� j |t
td� j d ��t � j
dd�d ��||< || S )
aV
Return the number of generators.
INPUT:
r: integer (optional)
If provided, return the number of generators of the given degree.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 0)
sage: R.ngens()
29
sage: R.ngens(2)
8
TESTS::
sage: R = TautologicalRing(2,0,moduli='ct')
sage: R.socle_degree()
1
sage: R.ngens()
3
sage: len(R.generators(1))
2
Nc 3 s | ]}� � |�V qd S rI )�ngens)rB rs rN r= r> rO � rE z)TautologicalRing.ngens.<locals>.<genexpr>r r ��
num_strataTr8 r: )r� r� r# r rq �_ngens�AttributeErrorr7 rN r~ r* r r" r2 )r8 rs rL rN r= rN r> rL � s "
4zTautologicalRing.ngensr c C s^ |dk s|| � |�kr td��|du rPd}|| � |�krP|| � |�8 }|d7 }q*| �|�| S )aW
Return the ``i``-th generator.
INPUT:
i : integer (default ``0``)
The number of the generator.
r : integer (optional)
If provided, return the ``i``-th generator in degree ``r``.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 0)
sage: R.gen(23)
Graph : [0, 1] [[3, 4, 5], [6]] [(3, 4), (5, 6)]
Polynomial : (kappa_1)_1
sage: [R.ngens(i) for i in range(4)]
[1, 3, 8, 17]
sage: R.gen(11,3)
Graph : [0, 1] [[3, 4, 5], [6]] [(3, 4), (5, 6)]
Polynomial : (kappa_1)_1
sage: R.gen(2, 3)
Graph : [2] [[]] []
Polynomial : (kappa_1^3)_0
TESTS::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 0)
sage: R.generators() == [R.gen(i) for i in range(R.ngens())]
True
sage: R.generators(3) == [R.gen(i, 3) for i in range(R.ngens(3))]
True
r zundefined generatorNr )rL r0 rJ )r8 rn rs r= r= r> �gen� s %
zTautologicalRing.genc C s@ | � |�}tt|��D ]$}tdt|� d t|| � � qdS )a
Lists all tautological classes of degree r in the tautological ring.
INPUT:
r : integer
The degree r of of the classes.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2,0)
sage: R.list_generators(2)
[0] : Graph : [2] [[]] []
Polynomial : (kappa_2)_0
[1] : Graph : [2] [[]] []
Polynomial : (kappa_1^2)_0
[2] : Graph : [1, 1] [[2], [3]] [(2, 3)]
Polynomial : (kappa_1)_0
[3] : Graph : [1, 1] [[2], [3]] [(2, 3)]
Polynomial : psi_2
[4] : Graph : [1] [[2, 3]] [(2, 3)]
Polynomial : (kappa_1)_0
[5] : Graph : [1] [[2, 3]] [(2, 3)]
Polynomial : psi_2
[6] : Graph : [0, 1] [[3, 4, 5], [6]] [(3, 4), (5, 6)]
Polynomial : 1
[7] : Graph : [0] [[3, 4, 5, 6]] [(3, 4), (5, 6)]
Polynomial : 1
�[z] : N)rJ r� rh �printrL )r8 rs �Lrn r= r= r> �list_generators� s
z TautologicalRing.list_generatorsc s� |du r6g }t | �� d �D ]}|�| �|�� q |S | jtkrHtd��ddlm} | � |�� � fdd�|| j
| j |t | j d�D �S )a
Return a basis.
INPUT:
d : ``None`` (default) or integer
if ``None`` return a full basis if ``d`` is provided, return a basis
of the homogeneous component of degree ``d``
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2, 0)
sage: R.basis(2)
[Graph : [2] [[]] []
Polynomial : (kappa_2)_0,
Graph : [2] [[]] []
Polynomial : (kappa_1^2)_0]
sage: R2 = TautologicalRing(2, 1, moduli='ct')
sage: R2.basis(1)
[Graph : [2] [[1]] []
Polynomial : (kappa_1)_0,
Graph : [2] [[1]] []
Polynomial : psi_1]
Nr z)basis not implemented for treelike curvesrC c s g | ] }� | �qS r= r= r� �r� r= r> r| B
rE z*TautologicalRing.basis.<locals>.<listcomp>r� )
r� r# rI �basisr2 r! r$ r� rD rJ r~ r r )r8 r_ ru rD r= rV r> rW
s
zTautologicalRing.basisFc c s� | � � }t|d| j �D ]�}dd� t| j|dd� �D �}t|d �D ]l}g }t|�� �D ]2\}} | shqZ|�dg|d t |� � | ||< qZ| |||gd�}
|r�|||
fn|
V qFqdS )a�
Iterator over the polynomials in kappa and psi classes of degree ``d``.
For combout=True it returns a generator of triples
(kappalist, psidict, kppoly) of
* a list kappalist of exponents of kappa_i,
* a dictionary psidict sending i to the exponent of psi_i,
* the associated TautologicalClass for this monomial.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: for a in TautologicalRing(0, 4).kappa_psi_polynomials(1): print(a)
Graph : [0] [[1, 2, 3, 4]] []
Polynomial : (kappa_1)_0
Graph : [0] [[1, 2, 3, 4]] []
Polynomial : psi_1
Graph : [0] [[1, 2, 3, 4]] []
Polynomial : psi_2
Graph : [0] [[1, 2, 3, 4]] []
Polynomial : psi_3
Graph : [0] [[1, 2, 3, 4]] []
Polynomial : psi_4
sage: for a in TautologicalRing(1, [2,7]).kappa_psi_polynomials(1): print(a)
Graph : [1] [[2, 7]] []
Polynomial : (kappa_1)_0
Graph : [1] [[2, 7]] []
Polynomial : psi_2
Graph : [1] [[2, 7]] []
Polynomial : psi_7
Here is the option where the combinatorial data is output separately::
sage: for a in TautologicalRing(1, [2,7]).kappa_psi_polynomials(1, True): print(a)
([1], {}, Graph : [1] [[2, 7]] []
Polynomial : (kappa_1)_0)
([], {2: 1}, Graph : [1] [[2, 7]] []
Polynomial : psi_2)
([], {7: 1}, Graph : [1] [[2, 7]] []
Polynomial : psi_7)
r c S s i | ]\}}|r||�qS r= r= )rB rn r r= r= r> rD r
rE z:TautologicalRing.kappa_psi_polynomials.<locals>.<dictcomp>Nr )r r )
r� r r �zipr� r r� r+ rI rh ) r8 r_ ZcomboutZtriv�Vr ZkVr rn r �clr= r= r> �kappa_psi_polynomialsD
s ,
z&TautologicalRing.kappa_psi_polynomialsc C s. ddl m} || j|ttd| jd ��| j�S )ao
INPUT:
r : integer
degree
TESTS::
sage: from admcycles import *
sage: R = TautologicalRing(1,2)
sage: R.num_gens(1)
5
sage: len(R.generators(1))
5
sage: R = TautologicalRing(1,2,moduli='ct')
sage: R.num_gens(1)
4
r rM )r7 rN r~ r* r� r r2 )r8 rs rN r= r= r> r� }
s zTautologicalRing.num_gensc s� | � � | }|dur2| �|���fdd�|D �}n|rB| �|�}n
| �|�}|durr| �|�� � fdd�|D ��n|r�| �|��n
| �|��tt�fdd�|D ��}|�� |S )a�
Computes the matrix of the intersection pairing of generators in
degree d (rows) against generators of opposite degree (columns).
INPUT:
d : integer
degree of the classes associated to rows
basis : bool (default: False)
compute pairing of basis elements in the two degrees
ind_d, ind_dcomp: tuple (optional)
lists of indices of generators in degrees d and its complementary degree
NOTE:
The matrix is returned as an immutable object, to allow caching.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1,2)
sage: R.pairing_matrix(1)
[ 1/8 1/12 1/12 1/24 1]
[ 1/12 1/24 1/24 0 1]
[ 1/12 1/24 1/24 0 1]
[ 1/24 0 0 -1/24 1]
[ 1 1 1 1 0]
sage: R.pairing_matrix(1, basis=True)
[ 1/8 1/12]
[1/12 1/24]
sage: R.pairing_matrix(1, ind_d=(0,1), ind_dcomp=(1,2,3))
[1/12 1/12 1/24]
[1/24 1/24 0]
Nc s g | ] }� | �qS r= r= r� )�allgensr= r> r| �
rE z3TautologicalRing.pairing_matrix.<locals>.<listcomp>c s g | ] }� | �qS r= r= r� )� allcogensr= r> r| �
rE c s g | ]� � fd d��D ��qS )c s g | ]}� | � � �qS r= r� )rB �b�r r= r> r| �
rE z>TautologicalRing.pairing_matrix.<locals>.<listcomp>.<listcomp>r= �rB )�cogensr_ r> r| �
rE )r# rJ rW r r �
set_immutable)r8 r_ rW Zind_dZ ind_dcomp�dcompr� �Mr= )r] r\ ra r> �pairing_matrix�
s &
z TautologicalRing.pairing_matrixc
C sH ddl m} t|�| jkr"td��| | j|ddddddd| j| �� d� S )a�
Return the k-twisted double ramification cycle in genus g and codimension d
for the partition Avector of k*(2g-2+n). For more information see the documentation
of :func:`~admcycles.double_ramification_cycle.DR_cycle`.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2,2)
sage: DR = R.double_ramification_cycle([1,3], k=1, d=1)
sage: (DR * R.psi(1)^3).evaluate()
-11/1920
r )�DR_cyclez$length of argument Avector must be nNFT) r_ r� �rpoly�tautoutrW � chiodo_coeff�r_coeffr� r� )�double_ramification_cyclerf rh r r0 r~ r2 r� )
r8 ZAvectorr_ r� rg rh rW ri rj rf r= r= r> rk �
s z*TautologicalRing.double_ramification_cyclec C s$ ddl m} | || j| j| jd��S )a�
Return the class Theta_{g,n} from [Norbury - A new cohomology class on the moduli space of curves].
For more information see the documentation of :func:`~admcycles.double_ramification_cycle.ThetaClass`.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1, 1)
sage: R.theta_class()
Graph : [1] [[1]] []
Polynomial : 11/6*(kappa_1)_0 + 1/6*psi_1
<BLANKLINE>
Graph : [0] [[3, 4, 1]] [(3, 4)]
Polynomial : 1/24
sage: R = TautologicalRing(2, 1, moduli='ct')
sage: R.theta_class()
0
r )�
ThetaClassr� )rk rl r~ r r2 )r8 rl r= r= r> � theta_class�
s z TautologicalRing.theta_classc C s8 |d| | j krtd��ddlm} | || j||��S )a
Return the cycle class of the hyperelliptic locus of genus g curves with n marked
fixed points and m pairs of conjugate points in `\bar M_{g,n+2m}`.
For more information see the documentation of :func:`~admcycles.admcycles.Hyperell`.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2,1)
sage: H = R.hyperelliptic_cycle(1,0)
sage: H.forgetful_pushforward([1]).fund_evaluate()
6
r� �<the number n+2m must equal the total number of marked pointsr )�Hyperell)r r0 r� ro r~ )r8 r� �mro r= r= r> �hyperelliptic_cycle�
s z$TautologicalRing.hyperelliptic_cyclec C s8 |d| | j krtd��ddlm} | || j||��S )a-
Return the cycle class of the bielliptic locus of genus g curves with n marked
fixed points and m pairs of conjugate points in `\bar M_{g,n+2m}`.
For more information see the documentation of :func:`~admcycles.admcycles.Biell`.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1,2)
sage: B = R.bielliptic_cycle(0,1)
sage: B.degree_list()
[1]
sage: B.forgetful_pushforward([2]).fund_evaluate()
3
r� rn r )�Biell)r r0 r� rr r~ )r8 r� rp rr r= r= r> �bielliptic_cycle
s z!TautologicalRing.bielliptic_cyclec C s< t |�| jkrtd��ddlm} | |||||| j| j��S )a�
Computes the Chern class c_deg of the derived pushforward of a line bundle
\O(D) on the universal curve C_{g,n} over the space Mbar_{g,n} of stable curves, for
D = l \tilde{K} + sum_{i=1}^n d_i \sigma_i + \sum_{h,S} a_{h,S} C_{h,S}
where the numbers l, d_i and a_{h,S} are integers, \tilde{K} is the relative canonical
class of the morphism C_{g,n} -> Mbar_{g,n}, \sigma_i is the image of the ith section
and C_{h,S} is the boundary divisor of C_{g,n} where the moving point lies on a genus h
component with markings given by the set S.
For more information see the documentation of :func:`~admcycles.GRRcomp.generalized_lambda`.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(2,1)
sage: l = 1; d = [0]; a = []
sage: t = R.generalized_lambda(1,l,d,a)
sage: t.basis_vector()
(1/2, -1/2, -1/2)
zBthe number of entries of d equal the total number of marked pointsr )�generalized_lambda)rh r r0 �GRRcomprt r~ )r8 �degr� r_ r rt r= r= r> rt # s z#TautologicalRing.generalized_lambdar= r c
C s> t |�| jkrtd��ddlm} | || j||||||d��S )ad
Return the fundamental class of the closure of the stratum of ``k``-differentials
with vanishing and pole orders ``mu``.
For more information see the documentation of :func:`~admcycles.stratarecursion.Strataclass`.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: R = TautologicalRing(1,2)
sage: H1 = R.differential_stratum(1,(1, -1))
sage: H1.is_zero()
True
sage: H5 = R.differential_stratum(1,(5, -5))
sage: H5.forgetful_pushforward([2]).fund_evaluate()
24
zGthe length of partition mu must equal the total number of marked pointsr )� Strataclass)�virt�res_cond�xi_power�method)rh r r0 �stratarecursionrw r~ )r8 r� �murx ry rz r{ rw r= r= r> �differential_stratum? s z%TautologicalRing.differential_stratum�presc s |s t d�S |dkr$|dur$t d�S |du r@��� }|du r@d}|du rLd}|dv rXd}g �g �|D ]H}t|�� �dks�t d � S t|�� �}|d
ksd��|� ��|� qdtd ��}t��}ttd ||d
�� � � � } ��
� ���fdd�t t���D �}
dd� |
D �} � � � fdd�| D ��} g }
t d�d �D ]��t
���}�fdd�|D �}� fdd�|D ��t�fdd�|D ���� � � }|D ]0�t��fdd�t t���D ��}|
�|� �q��q4� � |
�| �� }g }t |�D ]�}|| d }d}|D ]B}|�| | �d
k�s�|�| | ��� �r�d}|�|� �q8�q�|�r܈ � |��| | �}|� � }�q�|�r�|D ]"}� j| | dd
�� ��|� �qh� � t|��}|dk�r�� ����}||fS |dk�r�|�� � � fS |dk�r�� ����}� �fdd�}|||fS dS )a_
Computes a presentation of the tautological ring as a quotient of
a polynomial ring by an ideal, where the generators of the polynomial
ring are sent to the given generators.
The function returns the above ideal in a polynomial ring together with
a ring homomorphism. Assumes FZ relations are sufficient unless otherwise
instructed.
INPUT:
- generators (list) --- optional, if provided we will use the given
elements as ring generators (it is the user's responsibility to check
they generate as an algebra)
- elimimate_generators (bool) --- optional, decides whether to keep around unnecessary ring generators.
- output (str) --- optional. Can be::
'pres', in which case returns a surjecion from a polynomial ring to self, and an ideal of that ring (the kernel)
'lists', in which case it returns generators for the ideal, then lists of generators for R and a correspondng list of generators for TR.
'fun', in which case it returns an ideal, a rung hom from free polynomial ring to self, and a function from self to free polynomial ring (a lift). This does not allow the user to choose their own basis.
EXAMPLES::
sage: from admcycles import TautologicalRing
sage: TR = TautologicalRing(2,0)
sage: I, f = TR.presentation()
sage: R = I.ring()
sage: I == R.ideal([2*R.0*R.1 + R.1^2, 40*R.0^3 - 43*R.1^3, R.1^4])
True
sage: R.ngens()
2
sage: I, f = TR.presentation(eliminate_generators = False)
sage: R = I.ring()
sage: R.ngens()
5
By specifying generators lambda_1 and delta_1, we can check a result by
Faber.::
sage: gens = (TR.lambdaclass(1), 1/2*TR.sepbdiv(1,()))
sage: I, f = TR.presentation(gens)
sage: R = I.ring()
sage: x0, x1 = R.gens()
sage: I == R.ideal([x1^2 + x0*x1, 5*x0^3 - x0^2 * x1])
True
sage: r = f(x1^2 + x0*x1)
sage: r.is_zero()
True
Going to the locus of smooth curves, we check Theorem 1.1 in [CanLars]_ by Canning-Larson (we correct the exponent of kap1 in the last term).::
sage: TR = TautologicalRing(7, 0, moduli = 'sm')
sage: gens = (TR.kappa(1), TR.kappa(2))
sage: I, f = TR.presentation(gens)
sage: R = I.ring(); R
Multivariate Polynomial Ring in x0, x1 over Rational Field
sage: kap1, kap2 = R.gens()
sage: idgens = [2423*kap1^2*kap2 - 52632*kap2^2, 1152000*kap2^2 - 2423*kap1^4, 16000*kap1^3*kap2 - 731*kap1^5]
sage: I == R.ideal(idgens)
True
Theorem 1.2 in [CanLars]_ (we correct the signs in the first term).::
sage: TR = TautologicalRing(8, 0, moduli = 'sm')
sage: gens = (TR.kappa(1), TR.kappa(2))
sage: I, f = TR.presentation(gens)
sage: R = I.ring(); R
Multivariate Polynomial Ring in x0, x1 over Rational Field
sage: kap1, kap2 = R.gens()
sage: idgens = [714894336*kap2^2 - 55211328*kap1^2*kap2 + 1058587*kap1^4, 62208000*kap1*kap2^2 - 95287*kap1^5, 144000*kap1^3*kap2 - 5617*kap1^5]
sage: I == R.ideal(idgens)
True
Theorem 1.3 in [CanLars]_ (corrected the last coefficient of the third generator).::
sage: TR = TautologicalRing(9, 0, moduli = 'sm')
sage: gens = (TR.kappa(1), TR.kappa(2), TR.kappa(3))
sage: I, f = TR.presentation(gens)
sage: R = I.ring(); R
Multivariate Polynomial Ring in x0, x1, x2 over Rational Field
sage: kap1, kap2, kap3 = R.gens()
sage: idgens = [5195*kap1^4 + 3644694*kap1*kap3 + 749412*kap2^2 - 265788*kap1^2*kap2, 33859814400*kap2*kap3 - 95311440*kap1^3*kap2 + 2288539*kap1^5, 19151377*kap1^5 + 16929907200*kap1*kap2^2 - 1142345520*kap1^3*kap2, 1422489600*kap3^2 - 983*kap1^6, 1185408000*kap2^3 - 47543*kap1^6]
sage: I == R.ideal(idgens)
True
z3Need to insert a step checking FZ conjecture here. �funNz�if you want an inverse, please let me choose my own generators for now. Otherwise I would have to do a bit of linear algebra... TF)�listsr� r z7So far needs to assume the generators are homogeneous. r �wdeglex�x)�orderc s g | ]}t �| d � ��qS r� r r� )�gen_degree_list�maxdegr= r> r| � rE z1TautologicalRing.presentation.<locals>.<listcomp>c S s g | ]}|D ]}|�q qS r= r= )rB r^ r r= r= r> r| � rE c s g | ]}� t |�d i��qS r� �r* )rB r �rt r= r> r| � rE c s, g | ]$� t �� fd d�tt���D ���qS )c s g | ]}� | �| �qS r= r= r� )r� �wr= r> r| � rE z<TautologicalRing.presentation.<locals>.<listcomp>.<listcomp>)r r� rh r` rV )r� r> r| � rE c s g | ]}� t |�d i��qS r� r� )rB r� r� r= r> r| � rE c s g | ]}|� � ��qS r= )rp )rB rp )rv r= r> r| � rE c s g | ]}�| � | �qS r= r= r� )�poly_monomials_to_tryrs r= r> r| � rE � degrevlexr r� c sj d}d� t d��� �D ]@}| �|��|t�� �fdd�t t���D ��7 }� t��7 � q|| �d�d S )Nr r c s$ g | ] }�| � � � |� �qS r= rV r� )rt �gennum�vdr= r> r| � rE z<TautologicalRing.presentation.<locals>.f.<locals>.<listcomp>)r� r# rp r� rh )ZtauteltZpolyeltr_ )rt r8 )r� r� r> r� � s
&z(TautologicalRing.presentation.<locals>.f)r$ rW rh rr �maxr r r r r� r# r� �idealr r �kernelr� �groebner_basis� coefficient� is_constant�elimination_ideal�
remove_varrj r+ �hom)r8 rJ Z assume_FZZeliminate_generators�outputrQ rp �TrL r� �LLZLL2Z deg_ideal�
ideal_gensZexponent_tuples_to_tryZtaut_monomials_to_try�relsrH �genlistZelimlistrn Zelimr� �I�IIZRhomr= )rt rv r� r� r� r� rs r8 r> � presentationX s� V
(
z TautologicalRing.presentation)T)NNN)N)N)N)r N)N)F)FNN)NNFTFFN)r r )r r )Fr= r r )NTNr ):r� r� r� r� r' �Element� staticmethodr� r( r� r r� r� r� r� r r rR r# r� r r rq r� r r� r r r r
�irrbdivr �sepbdivr r r- r3 r� rE ro rJ r� rL rQ rU rW r[ r� re rk rm rq rs rt r~ r& r� �
__classcell__r= r= r� r> r� sn A>
-
'("
M&=<
GJ B
Z
.
/%
'
9 <
r� c @ sJ e Zd ZdZdZdd� Zdd� Zdd� Zd d
� Zd d � Z d
d� Z
e j Z dS )r aM
Construction functor for tautological ring.
This class is the way to implement the "promotion of base ring" (see below in the examples).
EXAMPLES::
sage: from admcycles.tautological_ring import TautologicalRing, TautologicalRingFunctor
sage: F = TautologicalRingFunctor(1, (1,), 'st')
sage: F(QQ)
TautologicalRing(g=1, n=1, moduli='st') over Rational Field
sage: x = polygen(QQ, 'x')
sage: (x**2 + 2) * TautologicalRing(1, 1).generators(1)[0]
Graph : [1] [[1]] []
Polynomial : (x^2 + 2)*(kappa_1)_0
�
c C s$ t �| tt� || _|| _|| _d S rI )r
r( r� rC r� r� )r8 rC r� r� r= r= r> r( s z TautologicalRingFunctor.__init__c C s d� | j| jt| j �S )Nz0TautologicalRingFunctor(g={}, n={}, moduli={!r}))r� rC r� r r� rN r= r= r> rR s �z TautologicalRingFunctor._repr_c C s t | j| j| j|d�S )Nr� )r� rC r� r� )r8 rt r= r= r> �_apply_functor s z&TautologicalRingFunctor._apply_functorc C s@ t |t�r<| j|jkr<| j|jkr<t| j| jt| j|j��S dS )zE
Return the merge of two tautological ring functors.
N)r) r rC r� �minr� r r= r= r> �merge s
�
�z TautologicalRingFunctor.mergec C s. t |t�o,| j|jko,| j|jko,| j|jkS rI )r) r rC r� r� r r= r= r> �__eq__& s
�
�
�z TautologicalRingFunctor.__eq__c C s
| |k S rI r= r r= r= r> �__ne__, s z TautologicalRingFunctor.__ne__N)
r� r� r� r� �rankr( rR r� r� r� r� r �__hash__r= r= r= r> r � s r )Ar� r� �sage.misc.cachefuncr �sage.misc.misc_cr �$sage.structure.unique_representationr �sage.structure.richcmpr r �sage.structure.elementr r �sage.structure.allr �sage.categories.functorr
�sage.categories.pushoutr �sage.categories.algebrasr �sage.categories.ringsr
�sage.arith.allr r r �sage.combinat.allr � sage.combinat.integer_vectorr �sage.rings.ringr �sage.rings.integer_ringr �sage.rings.rational_fieldr � sage.modules.free_module_elementr �1sage.rings.polynomial.polynomial_ring_constructorr � sage.rings.polynomial.term_orderr �%sage.combinat.integer_vector_weightedr �sage.matrix.constructorr r� r r r! r" r# r� r$ � stable_graphr% Zidentify_classesr& r� r� r' r� r r= r= r= r> �<module> sh
{ k