unlisted
ubuntu2004o
��c�� � @ s� d dl mZ d dlmZ d dlmZ d dlmZ d dlm Z d dl
m Z d dl m
Z
d dlmZ d d lmZ d d
lmZ d d lmZ G d d
� d
e�ZdS )� )�deepcopy)�
SageObject)�ZZ)�flatten)�sign)�
cached_method)�Graph)�text)� GraphIsom)� StableGraph)�
kSignaturec @ s� e Zd ZdZ d�dd�Ze d�dd��Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z e dd� �Z
edd� �Ze d�dd��Ze dd� �Ze dd� �Ze d d � �Ze d d � �Ze d d!� �Ze d"d#� �Ze d$d%� �Ze d&d'� �Ze d(d)� �Ze d*d+� �Ze d,d-� �Ze d.d/� �Z e d�d0d1��Z e d2d3� �Z d4d5� Z e d6d7� �Z e d8d9� �Z!e d:d;� �Z"e d<d=� �Z#e d>d?� �Z$e d@dA� �Z%e dBdC� �Z&e dDdE� �Z'e dFdG� �Z(e d�dHdI��Z)e dJdK� �Z*e dLdM� �Z+e dNdO� �Z,e dPdQ� �Z-e dRdS� �Z.e dTdU� �Z/e d�dVdW��Z0e d�dXdY��Z1e d�dZd[��Z2e d�d\d]��Z3d^d_� Z4d`da� Z5dbdc� Z6ddde� Z7dfdg� Z8dhdi� Z9djdk� Z:dldm� Z;dndo� Z<d�dpdq�Z=d�dsdt�Z>d�dudv�Z?d�dwdx�Z@dydz� ZAd{d|� ZBd}d~� ZCdd�� ZDd�d�� ZEd�d�d��ZFd�d�� ZGdS )�� KLevelGrapha�
Create a (stable) level graph for a k-differential.
.. NOTE::
This is a low-level class and should NEVER be invoked directly!
Preferably, ``EmbeddedLevelGraphs`` should be used and these should be
generated automatically by ``Stratum`` (or ``GeneralisedStratum``).
.. NOTE::
We do not inherit from stgraph/StableGraph anymore, as KLevelGraphs
should be static objects!
Extends admcycles stgraph to represent a level graph as a stgraph,
i.e. a list of genera, a list of legs and a list of edges, plus a list of
poleorders for each leg and a list of levels for each vertex.
Note that the class will warn if the data is not admissible, i.e. if the
graph is not stable or the pole orders at separating nodes across levels do
not add up to -2 or -1 on the same level (unless this is suppressed with
quiet=True).
INPUT:
genera : list
List of genera of the vertices of length m.
legs : list
List of length m, where ith entry is list of legs attached to vertex i.
By convention, legs are unique positive integers.
edges : list
List of edges of the graph. Each edge is a 2-tuple of legs.
poleorders : dictionary
Dictionary of the form leg number : poleorder
levels : list
List of length m, where the ith entry corresponds to the level of
vertex i.
By convention, top level is 0 and levels go down by 1, in particular
they are NEGATIVE numbers!
k : int
The order of the differential.
quiet : optional boolean (default = False)
Suppresses most error messages.
ALTERNATIVELY, the pole orders can be supplied as a list by calling
KLevelGraph.fromPOlist:
poleorders : list
List of order of the zero (+) or pole (-) at each leg. The ith element
of the list corresponds to the order at the leg with the marking i+1
(because lists start at 0 and the legs are positive integers).
EXAMPLES:
Creating a level graph with three components on different levels of genus 1,
3 and 0. The bottom level has a horizontal node.::
sage: from admcycles.diffstrata.klevelgraph import KLevelGraph
sage: G = KLevelGraph.fromPOlist([1,3,0],[[1,2],[3,4,5],[6,7,8,9]],[(2,3),(5,6),(7,8)],[2,-2,0,6,-2,0,-1,-1,0],[-2,-1,0],1); G # doctest: +SKIP
KLevelGraph([1, 3, 0],[[1, 2], [3, 4, 5], [6, 7, 8, 9]],[(3, 2), (6, 5), (7, 8)],{1: 2, 2: -2, 3: 0, 4: 6, 5: -2, 6: 0, 7: -1, 8: -1, 9: 0},[-2, -1, 0],1,True)
or alternatively::
sage: KLevelGraph([1, 3, 0],[[1, 2], [3, 4, 5], [6, 7, 8, 9]],[(3, 2), (6, 5), (7, 8)],{1: 2, 2: -2, 3: 0, 4: 6, 5: -2, 6: 0, 7: -1, 8: -1, 9: 0},[-2, -1, 0],1,quiet=True)
KLevelGraph([1, 3, 0],[[1, 2], [3, 4, 5], [6, 7, 8, 9]],[(3, 2), (6, 5), (7, 8)],{1: 2, 2: -2, 3: 0, 4: 6, 5: -2, 6: 0, 7: -1, 8: -1, 9: 0},[-2, -1, 0],1,True)
Creating a level graph with two components on different levels of genus 1 and 1 and a quadratic differential.::
sage: KLevelGraph.fromPOlist([1,1],[[1],[2,3]],[(1,2)],[0,-4,4],[0,-1],2)
KLevelGraph([1, 1],[[1], [2, 3]],[(1, 2)],{1: 0, 2: -4, 3: 4},[0, -1],2,True)
We get a warning if the graph has non-stable components: (not any more ;-))::
sage: G = KLevelGraph.fromPOlist([1,3,0,0],[[1,2],[3,4,5],[6,7,8,9],[10]],[(2,3),(5,6),(7,8),(9,10)],[2,-2,0,6,-2,0,-1,-1,0,-2],[-3,-2,0,-1],1); G # doctest: +SKIP
Warning: Component 3 is not stable: g = 0 but only 1 leg(s)!
Warning: Graph not stable!
KLevelGraph([1, 3, 0, 0],[[1, 2], [3, 4, 5], [6, 7, 8, 9], [10]],[(3, 2), (6, 5), (7, 8), (9, 10)],{1: 2, 2: -2, 3: 0, 4: 6, 5: -2, 6: 0, 7: -1, 8: -1, 9: 0, 10: -2},[-3, -2, 0, -1],1,True)
Fc
s� d}t |�t |�krtd��|| _|| _|| _� | _|| _t� fdd�| �� D ��} t | |�| _
d | _ | � � |r>| �
|� d | _i | _d | _d S )NFz)genera and legs must have the same lengthc 3 s � | ]}� | V qd S �N� ��.0�l��
poleordersr �D/home/user/Introduction lectures/admcycles/diffstrata/klevelgraph.py� <genexpr>p s � z'KLevelGraph.__init__.<locals>.<genexpr>)�len�
ValueError�genera�legs�edgesr �levels�tuple�
list_markingsr �sig�_stgraph�
_init_more�checkadmissible�_has_long_edge�_is_long�_is_bic)
�selfr r r r r �k�quiet�checks�sig_listr r r �__init__e s"
zKLevelGraph.__init__c sp t t|���t��t� �kr tdtt��� d tt� �� ��� �fdd�tt���D �}| |||||||�S )zz
This gives a KLevelGraph where the poleorders are given as a list, not
directly as a dictionary.
z4Numbers of legs and pole orders do not agree! Legs: z Pole orders: c s i | ] }�| � | �qS r r �r �i��poleordersaslist�
sortedlegsr r �
<dictcomp>� � �z*KLevelGraph.fromPOlist.<locals>.<dictcomp>)�sortedr r r �repr�range) �clsr r r r/ r r' r( �
poleorderdictr r. r �
fromPOlist{ s
��
�
�zKLevelGraph.fromPOlistc C s d| � � d S )Nz KLevelGraph(�))�input_as_string�r& r r r �__repr__� s zKLevelGraph.__repr__c C s t t| ��S r )�hashr4 r; r r r �__hash__� s zKLevelGraph.__hash__c C sT dt | j� d t | j� d t | j� d t | j� d t | j� d t | j� S )Nz KLevelGraph � )r4 r r r r r r' r; r r r �__str__� sH �������� �
�� �
������zKLevelGraph.__str__c C sV t | j�d t | j� d t | j� d t | j� d t | j� d t | jj� d S )zX
return a string that can be given as argument to __init__ to give self
�,z,True)r4 r r r r r r r' r; r r r r: � s" ������
��zKLevelGraph.input_as_stringc C sb t |t�sdS | j|jko0| j|jko0| j|jko0t| j�t|j�ko0| j|jko0| jj |jj kS )NF)
�
isinstancer
r r r �setr r r r' )r& �otherr r r �__eq__� s(
�
�
�����
��zKLevelGraph.__eq__c C sH t | j�t| j� t| j� t�� }|| jjks"J d| j| f ��|S )Nz Signature %r does not match %r!)�sumr r r r �oner �g)r& �genusr r r rH � s ���z
KLevelGraph.gc C s8 | j d u rtdd� | jD �dd� | jD �| j�| _ | j S )Nc S � g | ]}t |��qS r ��int)r rH r r r �
<listcomp>� � z'KLevelGraph.stgraph.<locals>.<listcomp>c S s g | ] }d d� |D ��qS )c S rJ r rK r r r r rM � rN z2KLevelGraph.stgraph.<locals>.<listcomp>.<listcomp>r )r �leg_listr r r rM � r2 )r �stgraphr r r r; r r r rP � s
��zKLevelGraph.stgraphNc sV |du rt � fdd�tt� j��D ��S t� j| �}� jD ]}|t|�8 }q t |�S )zR
Return the list of markings (non-edge legs) of self at vertex v.
Nc s g | ] }� � |�D ]}|�q qS r )r )r �v�jr; r r rM � s
�
�z-KLevelGraph.list_markings.<locals>.<listcomp>)r r5 r r rC r r )r& rQ �s�er r; r r � s
zKLevelGraph.list_markingsc C �
| j | S )z�
The vertex (as index of genera) where leg is located.
Args:
leg (int): leg
Returns:
int: index of genera
)�legdict�r& �legr r r �vertex) s
zKLevelGraph.vertexc C s t tt| j���S r ��listr5 r r r; r r r � vertex_list6 s zKLevelGraph.vertex_listc C s | j S r �r r; r r r �
edges_list: s zKLevelGraph.edges_listc C rU r �r �r& rQ r r r �
levelofvertex> �
zKLevelGraph.levelofvertexc C s | � | �|��S r )ra rY rW r r r �
leveloflegB s zKLevelGraph.leveloflegc C rU r r rW r r r �
orderatlegF rb zKLevelGraph.orderatlegc � � fdd�� � |�D �S )Nc � g | ]}� � |��qS r �rd �r rX r; r r rM L � z.KLevelGraph.ordersonvertex.<locals>.<listcomp>�� legsatvertexr` r r; r �ordersonvertexJ � zKLevelGraph.ordersonvertexc s � �fdd�t t�j��D �S )Nc � g | ] }�� |�� kr|�qS r �ra �r rQ ��levelr& r r rM P �
�z/KLevelGraph.verticesonlevel.<locals>.<listcomp>)r5 r r �r& rr r rq r �verticesonlevelN s zKLevelGraph.verticesonlevelc s � �fdd�� j D �S )Nc s4 g | ]}� � |d ��ks� � |d ��kr|�qS �r � �rY �r rT r` r r rM U �
�z-KLevelGraph.edgesatvertex.<locals>.<listcomp>r] r` r r` r �
edgesatvertexS s zKLevelGraph.edgesatvertexc C rU r �r r` r r r rk X rb zKLevelGraph.legsatvertexc s t � fdd�| jD ��S )z:
Check if leg has an edge attached to it.
c 3 s( � | ]}|d � kp|d � kV qdS �r rw Nr ry �rX r r r a s �& z*KLevelGraph.is_halfedge.<locals>.<genexpr>)�anyr rW r r~ r � is_halfedge\ s zKLevelGraph.is_halfedgec re )Nc s g | ] }� � |�d kr|�qS )�����rg r r; r r rM e s z3KLevelGraph.simplepolesatvertex.<locals>.<listcomp>rj r` r r; r �simplepolesatvertexc rm z KLevelGraph.simplepolesatvertexc C s |du r| � � S | j| S )zp
Return the genus of vertex v.
If v is None, return genus of the complete KLevelGraph.
N)rH r r` r r r rI g s
zKLevelGraph.genusc C s t t| j��S r )r rC r r; r r r �numberoflevelss s zKLevelGraph.numberoflevelsc C s( | j d u r| �� dko| �� | _ | j S )N� )r% r� �
is_horizontalr; r r r �is_bicw s
zKLevelGraph.is_bicc s$ � � � d t� fdd�� jD �� S )zN
Return the codim = No. of levels of self + horizontal edges.
rw c 3 s � | ]
}� � |�rd V qdS )rw N�r� ry r; r r r � s � z$KLevelGraph.codim.<locals>.<genexpr>)r� rF r r; r r; r �codim| s
�zKLevelGraph.codimc � � �fdd��j D �S )zG
Return list of edges with at least one node at level.
c s4 g | ]}�� |d �� ks�� |d �� kr|�qS rv �rc ry rq r r rM � rz z,KLevelGraph.edgesatlevel.<locals>.<listcomp>r] rt r rq r � edgesatlevel� � zKLevelGraph.edgesatlevelc re )Nc s g | ] }� � |�r|�qS r r� ry r; r r rM � � z6KLevelGraph.horizontaledgesatlevel.<locals>.<listcomp>)r� rt r r; r �horizontaledgesatlevel� rm z"KLevelGraph.horizontaledgesatlevelc C s@ z
| j �|�d }W n
ty Y dS w |dkrdS | j | S )a�
Return the next lower level number or False if no legal level
(e.g. lowest level) is given as input.
Point of discussion: Is it better to tidy up the level numbers
to be directly ascending or not?
Pro tidy: * this becomes obsolete ;)
* easier to check isomorphisms?
Con tidy: * we "see" where we came from
* easier to undo/glue back in after cutting
rw Fr� )� sortedlevels�indexr )r& r Zllindexr r r �nextlowerlevel� s �
zKLevelGraph.nextlowerlevelc C s: t ttt t| j�����}t|�}|t|�krdS || S )a7
Return the internal i-th level, e.g.
self.levels = [0,-2,-5,-3]
then
internal_level_number(0) is 0
internal_level_number(1) is -2
internal_level_number(2) is -3
internal_level_number(3) is -4
Returns None if the level does not exist.
N)r[ �reversedr3 rC r �absr )r& r- �reference_levelsr r r �internal_level_number� s
z!KLevelGraph.internal_level_numberc C s< t ttt t| j�����}z|�|�W S ty Y dS w )a&
Return the relative level number (positive!) of l, e.g.
self.levels = [0,-2,-5,-3]
then
level_number(0) is 0
level_number(-2) is 1
level_number(-3) is 2
level_number(-5) is 3
Returns None if the level does not exist.
N)r[ r� r3 rC r r� r )r& r r� r r r � level_number� s �zKLevelGraph.level_numberc C s^ z| j | W S ty. t| �| �|d ��| �| �|d �� �dk}|| j |< | Y S w )zS
Check if edge e is long, i.e. passes through more than one level.
r rw )r$ �KeyErrorr� r� rc )r& rT �ilr r r �is_long� s
���
�zKLevelGraph.is_longc C s: | j d u r| jD ]}| �|�rd| _ | j S qd| _ | j S )NTF)r# r r� �r& rT r r r �
has_long_edge� s
�zKLevelGraph.has_long_edgec C s
| j d S )Nr )r� r; r r r � lowest_level� rb zKLevelGraph.lowest_levelc s^ |du rt � fdd�� jD ��S |� jvr!tdt|� d � dS � �|d �� �|d �kS ) zX
Check if edge e is a horizontal edge or if self has a horizontal edge.
Nc 3 s � | ]}� � |�V qd S r r� ry r; r r r � s � z,KLevelGraph.is_horizontal.<locals>.<genexpr>� Warning: z is not an edge of this graph!Fr rw )r r �printr4 rc r� r r; r r� � s
zKLevelGraph.is_horizontalc s t � fdd�� �|�D ��S )z/
Check if vertex v has a loop.
c 3 s, � | ]}� � |d �� � |d �kV qdS r} rx ry r; r r r s � $�z'KLevelGraph.has_loop.<locals>.<genexpr>)r r{ r` r r; r �has_loop� s �zKLevelGraph.has_loopc r� )zy
Return the edges going up from level l.
This uses that e[0] is not on a lower level than e[1]!
c �, g | ]}�� |d �� kr��|�s|�qS �rw �rc r� ry �r r& r r rM s
�z5KLevelGraph.edgesgoingupfromlevel.<locals>.<listcomp>r] �r& r r r� r �edgesgoingupfromlevel s z!KLevelGraph.edgesgoingupfromlevelc s8 � du r
t tt�j���S � �fdd�tt�j��D �S )zh
Return list of all vertices above level l.
If l is None, return all vertices.
Nc s g | ] }�� |�� kr|�qS r ro rp r� r r rM rs z-KLevelGraph.verticesabove.<locals>.<listcomp>rZ r� r r� r �
verticesabove s zKLevelGraph.verticesabovec r� )zm
Return a list of all edges above level l, i.e. start and end vertex
have level > l.
c s4 g | ]}�� |d �� kr�� |d �� kr|�qS rv r� ry r� r r rM s
�
�z*KLevelGraph.edgesabove.<locals>.<listcomp>r] r� r r� r �
edgesabove s zKLevelGraph.edgesabovec C s$ | � |d �|ko| � |d �|kS )zL
Check if e crosses level l (i.e. starts > l and ends <= l)
r rw r� )r& rT r r r r � crosseslevel# s $zKLevelGraph.crosseslevelc r� )zS
Return list of edges that go from above level l to below level l.
c s< g | ]}�� |d �� kr�� |d �krn n|�qS rv r� ry r� r r rM / s
� �z3KLevelGraph.edgesgoingpastlevel.<locals>.<listcomp>r] r� r r� r �edgesgoingpastlevel* r� z KLevelGraph.edgesgoingpastlevelc C sV d}| � |�s|s
td� d}| �|�s |std� d}| �|�s)|s'td� d}|S )a
Run all kinds of checks on the level graph. Currently:
* Check if orders on each komponent add up to k*(2g-2)
* Check if graph is stable
* Check if orders at edges sum to -k*2
* Check if orders respect level crossing
TzWarning: Illegal orders!FzWarning: Graph not stable!z"Warning: Illegal orders at a node!)� checkordersr� � is_stable�checkedgeorders)r& r( �
admissibler r r r" 8 s
zKLevelGraph.checkadmissiblec C sv t | j�D ]3\}}t| �|��| jjd| d kr8|s5tdt|� d tt| �|��� d t|� � dS qdS )zK
Check if the orders add up to k*(2g-2) on each component.
r� �Warning: Component z orders add up to z but component is of genus FT)� enumerater rF rl r r' r� r4 )r& r( rQ rH r r r r� P s" "������ zKLevelGraph.checkordersc C s� d| � � d t| j� }|dk r |stdt|� � dS tt| j��D ]7}d| � |� d t| �|�� dk r[|sXtdt|� d t| � |�� d tt| �|��� d � dS q$d
S ) z+
Check if graph is stable.
r� r z*Warning: Total graph not stable! 2g-2+n = F� r� z is not stable: g = z
but only z leg(s)!T)rI r �leglistr� r4 r5 r rk )r& r( rT rQ r r r r� a s0 $�� �����
zKLevelGraph.is_stablec
C s | j D ]|}| �|d �| �|d � }|| jj d kr1|s.tdt|� d t|� d � dS t| �|d �| �|d � �t| �|d �| �|d � �kr|s|tdt|� d � td | �|d �| �|d �fd
| �|d �| �|d �f� dS qd S ) zw
Check that the orders at nodes (i.e. edges) sum to -k*2 and that lower
level has lower order.
r rw r� zWarning: Orders at edge z add up to z instead of -k*2!Fz do not respect level crossing!zPoleorders arezbut levels areT)r rd r r' r� r4 r rc )r& r( rT �ordersr r r r� { s>
����� � ��� zKLevelGraph.checkedgeordersc s� t � j�� _t� j�� _� fdd�tt� j��D �� _ t
dd� � jD ��� _ t
dd� � jD ��� _ t
� fdd�tt� j��D �� fdd�� jD �gdd d d
�� _d S ) a$
This should be used _only_ for initialisation!
Make sure everything is in order, in particular:
* sortedlevels is fine
* leglist is fine
* legdict is fine
* maxleg is fine
* maxlevel is fine
* underlying graph is fine
c s" i | ]
}� j | D ]}||�q qS r r| )r rQ r r; r r r1 � s
� �z*KLevelGraph._init_more.<locals>.<dictcomp>c S s g | ] }t |d g ��qS �r )�max)r rR r r r rM � r� z*KLevelGraph._init_more.<locals>.<listcomp>c S rJ r )r� r r r r rM � rN c rf r �� UG_vertexr, r; r r rM � ri c s6 g | ]}� � � �|d ��� � � �|d ��|f�qS rv )r� rY ry r; r r rM � s .��vertices_and_edgesT��format�loops�
multiedgesN)r3 r r� r r r� r5 r r rV r� �maxleg�maxlevelr r �underlying_graphr; r r; r r! � s
�� �zKLevelGraph._init_morec C s || j | dfS )z�
Vertex of the underlying graph corresponding to v.
Args:
v (int): vertex number (index of self.genera)
Returns:
tuple: tuple encoding the vertex of the Underlying Graph.
�LG�r r` r r r r� � s
zKLevelGraph.UG_vertexc sz t � fdd�|D ��}t � fdd�|D ��}t |�}t � fdd�t|�D ��}t � fdd�|D ��}t|||||� jj�S )aE
Extract the subgraph of self (as a KLevelGraph) consisting of vertices
(as list of indices) and edges (as list of edges).
Returns the levelgraph consisting of vertices, edges and all legs on
vertices (of self) with their original poleorders and the original
level structure.
c � g | ]}� j | �qS r r� r, r; r r rM � ri z'KLevelGraph.extract.<locals>.<listcomp>c r� r r| r, r; r r rM � ri c � i | ]}|� � |��qS r rg r r; r r r1 � s �z'KLevelGraph.extract.<locals>.<dictcomp>c r� r r_ r, r; r r rM � ri )r r r
r r' )r& �verticesr Z newvertices�newlegs�newedges�
newpoleorders� newlevelsr r; r �extract� s �
�zKLevelGraph.extractc C s& dd� |j dd�D �}| �||�� �S )z�
Returns the KLevelGraph associated to a subgraph of underlying_graph
(with the level structure induced by self)
c S s g | ] }|d dkr|d �qS )r� r� r r rp r r r rM � � z8KLevelGraph.levelGraph_from_subgraph.<locals>.<listcomp>T��sort)r� r� � edge_labels)r& �Gr\ r r r �levelGraph_from_subgraph� s z$KLevelGraph.levelGraph_from_subgraphc s8 � fdd�� � |�D �}|dd� � jjdd�D �7 }|S )a
The vertices above (internal) level l (including possible vertices at infinity).
Used for checking residue conditions.
Args:
l (int): internal level number
Returns:
list: list of vertices of self.underlying_graph
c rf r r� r, r; r r rM � ri z7KLevelGraph.UG_vertices_above_level.<locals>.<listcomp>c S s g | ]
}|d dkr|�qS )r� �resr rp r r r rM � s
�Tr� )r� r� r� )r& r Zvertices_abover r; r �UG_vertices_above_level� s
z#KLevelGraph.UG_vertices_above_levelc C s$ | � |�}| �|�}| j�|�}|S )a=
Subgraph of Underlying Graph (including vertices at infinity) (strictly) above
(relative!) level l.
Args:
l (int): relative level number
Returns:
SAGE Graph: subgraph of self.underlying_graph with all vertices strictly
above level l.
)r� r� r� �subgraph)r& r �
internal_lr� �
abovegraphr r r �UG_above_level� s
zKLevelGraph.UG_above_levelc s$ � fdd�t � j�D �}� j�|�S )zy
Subgraph of Underlying Graph without the vertices at infinity.
Returns:
SAGE graph
c s g | ] \}}� � |��qS r r� )r r- �_r; r r rM r� z3KLevelGraph.UG_without_infinity.<locals>.<listcomp>)r� r r� r� )r& r� r r; r �UG_without_infinity s z KLevelGraph.UG_without_infinityc C s< t | �|d �| �|d �g�\}}| �|�s-tdt|� d � | j| j| j| j| j fS t
| j�}t
| j�}t
| j�}t
| j�}t
| j �}||krS|| d7 < n#|| || 7 < || || 7 < |� |� |� |� |� |� |� |� || � |d � || � |d � ||d = ||d = |||||gS )zZ
Squish the horizontal edge e and returns the raw data for the new graph.
r rw r� z- is not a horizontal edge -- Not contracting.)
r3 rY r� r� r4 r r r r r r �pop�remove) r& rT rQ �w� newgenerar� r� r� r� r r r �_squish_horizontal s4 $
� �
z KLevelGraph._squish_horizontalc C s" | � |�| jjg }t|ddi�S )aw
Squish the horizontal edge e and return the new graph.
EXAMPLES::
sage: from admcycles.diffstrata.klevelgraph import KLevelGraph
sage: G = KLevelGraph.fromPOlist([1,1], [[1,2],[3,4]], [(2,3)], [1,-1,-1,1],[0,0],1)
sage: G.squish_horizontal((2,3))
KLevelGraph([2],[[1, 4]],[],{1: 1, 4: 1},[0],1,True)
r( T)r� r r' r
)r& rT �datr r r �squish_horizontalG s
z KLevelGraph.squish_horizontalc s |du r�S �� |�� � du r"|stdt|� � |r �ddfS �S |s+td|d� � ��� �}� �fdd���|�D �}|sDtd|� t�j�}t�j�}t�j�}t�j �} t�j
�}
|D ]} ||
| < q_t |||| |
�j j
d �} |D ]}
| �|
�} qt|r�| d t|�fS | S )
a�
Squish the level l (and the next lower level!) and return the new graph.
If addata=True is specified, we additionally return a boolean that tells
us if a level was squished and the legs that no longer exist.
More precisely, adddata=True returns a tuple (G,boolean,legs) where
* G is the (possibly non-contracted) graph and
* boolean tells us if a level was squished
* legs is the (possibly empty) list of legs that don't exist anymore
Implementation:
At the moment, we remember all the edges (ee) that connect level l to
level l-1. We then create a new KLevelGraph with the same data as self,
the only difference being that all vertices of level l-1 have now been
assigned level l. We then remove all (now horizontal!) edges in ee.
In particular, all points and edges retain their numbering (only the level might have changed).
WARNING: Level l-1 does not exist anymore afterwards!!!
Downside: At the moment we get a warning for each edge in ee, as these
don't have legal pole orders for being horizontal (so checkedgeorders
complains each time the constructor is called :/).
NF�$Warning: Illegal level to contract: zSquishing levels�andc r� r� r� ry ��llr& r r rM � s
�
�z4KLevelGraph.squish_vertical_slow.<locals>.<listcomp>zContracting edgesT)r� r� r4 ru r� r r r r r r r
r r' r� r )r& r �adddatar( �vv�eer� r� r� r� r� rQ Z returngraphrT r r� r �squish_vertical_slowW sH
� z KLevelGraph.squish_vertical_slowTc s� |du r�S �� |�}t||g��|du r,|s tdt|� � n �j�j�j�j�jfS �� |��� |� }��fdd��jD �}�fdd�|D �}�fdd�|D �}�fd d�|D �}g � |r�|�
� \} }
|| } ||
} || = ||
= || � | � || � |
� � � | |
g� | | kr�|| d
7 < n"|| || 7 < || = || D ]
}
| ||
< || �
|
� q�|| = |s`t|�}t� �� g }g }g }tt�j��D ]>} | |v r�| |v r�|�
|| � |�
|| dd� � |�
|� q�|�
��| �� |�
��| �dd� � |�
��| �� q�g }�jD ]!\} }
| � v �r%|
� v �s#J ��q|
� v�s,J �|�
| |
f� �q� fd d��j�� D �}|||||gS ) a�
Squish the level l (and the next lower level!) and return the raw data for the new graph.
Implementation:
At the moment, we remember all the edges (ee) that connect level l to
level l-1. We then create a new KLevelGraph with the same data as self,
the only difference being that all vertices of level l-1 have now been
assigned level l. We then remove all edges in ee.
(In contrast to the old squish_vertical_slow, this is now done in
one step and not recursively so we avoid a lot of the copying of graphs.)
In particular, all points and edges retain their numbering (only the level might have changed).
WARNING: Level l-1 does not exist anymore afterwards!!!
Args:
l (int): (internal) level number
quiet (bool, optional): No output. Defaults to True.
Returns:
tuple: raw data of the new graph
NFr� c s4 g | ]}t ��|d ���|d �g�� kr|�qS rv )rC rc ry )�levelsetr& r r rM � s
� �z0KLevelGraph._squish_vertical.<locals>.<listcomp>c r� r �rI rp r; r r r1 � s z0KLevelGraph._squish_vertical.<locals>.<dictcomp>c s" i | ]
}� � |�D ]}||�q qS r rj )r rQ rX r; r r r1 � s
��c s i | ] }|� � |�d d � �qS r rj rp r; r r r1 � r� rw c s i | ] \}}|� vr||�qS r r )r rX �p)� deleted_legsr r r1 � s ��)r� rC r� r4 r r r r r ru r� r� �extend�appendr5 r rI rk ra �items)r& r r( r� r� r Zgenus_of_vertexZ
vertex_of_legZlegs_of_vertex�start�endrQ r� rX r� r� r� r� r� r )r� r� r& r �_squish_vertical� s|
�
� �
�
�z KLevelGraph._squish_verticalc C s& | j ||d�| jjg }t|ddi�S )a�
Squish the level l (and the next lower level!) and return the new graph.
In particular, all points and edges retain their numbering (only the level might have changed).
WARNING: Level l-1 does not exist anymore afterwards!!!
Args:
l (int): (internal) level number
quiet (bool, optional): No output. Defaults to True.
Returns:
KLevelGraph: new levelgraph with one level less.
EXAMPLES::
sage: from admcycles.diffstrata.klevelgraph import KLevelGraph
sage: G = KLevelGraph.fromPOlist([1,2], [[1],[2,3,4]], [(1,2)], [0,-2,1,3],[0,-1],1)
sage: G.squish_vertical(0)
KLevelGraph([3],[[3, 4]],[],{3: 1, 4: 3},[0],1,True)
�r( r( T)r� r r' r
)r& r r( r� r r r �squish_vertical s zKLevelGraph.squish_verticalc C sn | }| � � rtd� t|�S tt| �� d ��D ] }t|�d |kr#q|s*td|� |j| �|�|d�}q|S )af
Squish all levels except for the k-th.
Note that delta(1) contracts everything except top-level and that
the argument is interpreted via internal_level_number
WARNING: Currently giving an out of range level (e.g.
0 or >= maxlevel) squishes the entire graph!!!
Return the corresponding divisor.
z2Error: Cannot delta a graph with horizontal edges!rw zSquishing levelr� ) r� r� r r� r5 r� r� r� r� )r& r' r( r� r- r r r �delta s
zKLevelGraph.deltac sF t � j�� �� � fdd�t� �� �D �t� fdd�� jD ��f� _dS )aK
DEPRECATED!! DO NOT USE!!
Compute a bunch of invariants (as a quick check for not isommorphic).
Up to now we have:
* sorted list of genera (by level)
* number of edges
* number of levels
* names and pole orders of marked points
* sorted list of pole orders
c � g | ] }|� � |�f�qS r rg r r; r r rM X r2 z/KLevelGraph._init_invariant.<locals>.<listcomp>c rf r rg r r; r r rM Z ri N)r r r� r3 r r� �
_invariantr; r r; r �_init_invariantI s
�
�zKLevelGraph._init_invariantc C s | � � | jS )z-
DEPRECATED!!! DO NOT USE!!!
)r� r� r; r r r � invariant\ s zKLevelGraph.invariantc � t � �fdd�|�� D ��S )zZ
Check if a "vertex isomorphism" preserves the (relative) level structure
c 3 s8 � | ]\}}�j ���|��� j �� �|��kV qd S r )r� r� ra )r �sv�ov�rD r& r r r g s � � �z8KLevelGraph._genisom_preserves_levels.<locals>.<genexpr>��allr� �r& rD �dVr r� r �_genisom_preserves_levelsc s �z%KLevelGraph._genisom_preserves_levelsc r� )zE
Check if a "leg isomorphism" preserves pole orders.
c 3 s( � | ]\}}�� |�� � |�kV qd S r rg )r �sl�olr� r r r o s � �z<KLevelGraph._legisom_preserves_poleorders.<locals>.<genexpr>r� )r& rD �dLr r� r � _legisom_preserves_poleordersk s �z)KLevelGraph._legisom_preserves_poleordersc s � ��fdd��j D �S )z�
Give a dictionary translating the levels of self to other in accordance
with the dictionary of vertices dV.
c s& i | ]}|�� � ��|�d ��qS r� )ra ru r �r� rD r& r r r1 w � �z)KLevelGraph._leveliso.<locals>.<dictcomp>r_ r� r r r � _levelisor s �zKLevelGraph._levelisoc s: t �j� j�}� �fdd�|D �}|rt|�|fS t|�S )aZ
DEPRECATED!!! Instead, use EmbeddedLevelGraph!!!
Check if self is isomorphic to other.
Return boolean + list of isomorphisms if adddata=True.
Note that our isomorphisms are stgraph isomorphisms plus a dictionary
translating the level structure of self into that of other.
At the moment we use admcycles.GraphIsom and check which of these
preserve the KLevelGraph structure (using the above invariants, though!)
Probably it would be much faster to reimplement this for KLevelGraphs
as it seems quite redundant as is...
c s: g | ]\}}�� � |�r��� |�r||��� |�g�qS r )r� r r )r r� r r� r r rM � s
�
�z-KLevelGraph.is_isomorphic.<locals>.<listcomp>)r
rP �bool)r& rD r� �isomsZ
levelisomsr r� r �
is_isomorphicz s
zKLevelGraph.is_isomorphicc s� t �j�fdd��jD �gdddd�}|�tt�j��� �fdd��jD �}d}tt�j��D ]0� � �fd d��� � D �}|sAq0|d
� 7 }|D ]}|d ��
|� 7 }|d t �� |�� 7 }qIq0t
|� |jdd
|dd�t|ddddd� S )z�
Return a sage graphics object generated from a sage graph.
TODO: Some things that are still ugly:
* No legs!!
* currently the vertices have labels (index,genus)
* loops are vertical not horizontal
c s0 g | ]}� � |d �� � |d �� �|�f�qS rv )rY �prongry r; r r rM � s (�z(KLevelGraph.plot_obj.<locals>.<listcomp>r� Tr� c s& i | ]}|� fd d�� � |�D ��qS )c r� r r� rp r; r r rM � r� z3KLevelGraph.plot_obj.<locals>.<dictcomp>.<listcomp>)ru r r; r r r1 � r z(KLevelGraph.plot_obj.<locals>.<dictcomp>zMarked points: c rn r r� rh r� r r rM � rs z
At level %s: �
z
of order i� �ranked)r� � vertex_size�heights�layout)r g���������topF)�vertical_alignment� axis_coords�axes)r r r �relabelr[ r� r r3 rC r �
_pointtyper4 rd r� �plotr )r& r� �hZlegtextZpoints_at_levelrX r r� r �plot_obj� s:
���
� ����zKLevelGraph.plot_obj)Fr )FF)T)H�__name__�
__module__� __qualname__�__doc__r+ � classmethodr8 r< r> r@ r: rE r rH �propertyrP r rY r\ r^ ra rc rd rl ru r{ rk r� r� rI r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r" r� r� r� r! r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r
s� T
� �
Z
' *
I
e
)
r
N)�copyr �sage.structure.sage_objectr �sage.rings.integer_ringr �sage.misc.flattenr �sage.functions.generalizedr �sage.misc.cachefuncr �sage.graphs.graphr �sage.plot.textr Zadmcycles.admcyclesr
Zadmcycles.stable_graphr rP �admcycles.diffstrata.sigr r
r r r r �<module> s