2019-03-23
Some more properties of veering triangulations
is_quadrangulable
is_square_tiled
is_balanced
... it is not yet clear what are the implications between the
properties.
2019-02-21
What should be the answer of the functions is_flippable, is_forward_flippable
and is_backward_flippable when we have GREEN/PURPLE edges?
What are exactly PURPLE/GREEN edges? edges that are restricted to
be horizontal/vertical or edges that can be both BLUE/RED in
a neighborhood of horizontal/vertical?
2018-09-07
Note that there are easy upper bounds on the number of facets
(codimension one faces) of the core and geometric polytopes. To see
this: Cut down the parameter space using the equalities, to get a
single linear subspace of some dimension. If the triangulation is
core then this dimension is already the stratum dimension (as all
variables can be positive). Now cut down using the positivity
constraints - we get at most one facet for every positivity
constraint. Thus the number of facets of the core polytope is at most
twice the number of edges: 12g - 12 + 6p.
[This should be reduced to the number of small branches in the
vertical track plus the number of small branches in the horizontal
track, as the positivity of one of these implies positivity of the
edges "downstream" until the sink. Experiments show that there can be
dependencies between small branches, so the number of faces can be
smaller even smaller... ]
The geometric polytope is the same dimension (by assumption!) so the
number of additional facets is at most the number of flippable edges
(forward or backward). This is at most two-thirds the number of
edges, so we get 4g - 4 + 2p more giving an upper bound of
16g - 16 + 8p
faces. Note that the Keane faces where already counted previously,
and all faces are either Keane or Delaunay. Note furthermore that the
number of faces of any linear subspace intersected with the geometric
polytope has at most this number of facets as well.
Vincent conjectures that:
# small branches \leq # facets of core + dim - 2
This is can be checked with the following code
from veerer import *
from surface_dynamics import *
s = AbelianStratum(2)
A = Automaton.from_stratum(s)
m = 0
for vt in A:
P = vt.train_track_polytope(VERTICAL)
num_facets = sum(1 for c in P.minimized_constraints() if c.is_inequality())
num_small = len(vt.branches(VERTICAL)[0])
m = max(m, num_small - num_facets)
print(m, s.dimension())
which gives (2, 4). Also checked with
H0, H(0^2), H(0^3), H(0^4)
2018-09-04 - or a few days earlier
1. Compute the shape of the octagon surface. Guess the linear space.
Check it has the correct dimension. Carry it around and see if the
Veech automaton is finite. (I feel sure that it should be, but Ben
Dozier has expressed many doubts - why can't h_t orbits cause it to
crash through the thin part over and over again??? But that seems
crazy. Talk to Vincent about this again.)
[2018-09-27 Everybody gets confused by this point. There is a
persistent confusion between the core polytope (which the Veech disk
definitely does meet infinitely many times!) and the geometric
polytope. We should think of the core polytope as being an universal
cover of the complement of some variety inside of the stratum
component. So it is very large, and the Veech disk should meet it
many times.]
2. Give an algorithmic answer to Ursula's question (asked by other
people as well, eg a version asked by Alex Wright): given two
laminations, decide if they fill, and if so, build the quadratic
differential. This is yet another flip algorithm. Suppose that
\lambda and \mu are the two measured laminations. Put them in normal
position with respect to the triangulation. Add "punctures" at the
centers of all triangles. Now start flipping to "shorten" both
laminations... Collapsing fake punctures in pairs (or fake punctures
to real ones) as you go. At the end we discover that they don't fill
or we find the L^\infty Delaunay triangulation.
2018-08-31
1. Implementation of homology action. The fact that poles are allowed
to be in middle of edges is really cool for homology computation!
However, to drastically simplify things in a stratum such as
Q(1^n, -1^n) one would need to label the folded edges with
bigger labels than the non-folded ones. More precisely,
the current computation carries matrices of size num_edges
but it is possible to carry only num_edges - num_folded_edges.
Currently, the coefficients of the folded edges are simply
set to zero. The main issue for now is to build a correct
good_start because there might not be any non-folded BLUE
before a red.
2. better javascript code for the automaton! Still the scaling
is not wonderful and the automorphism group order displayed inside
the nodes makes it delicate to click on actual node.
2018-08-24
1. Discussed how L^\infty Del triangulations behave under
degeneration. Ian is full of ideas and points to his first paper on
the arXiv for a discussion of collapsing clusters of zeros. Some of
the relevant points are whether or not things converge in angle... Ie
we will allow \RR^* rescaling but of course not \CC^* rescaling.
2. We are wondering about the vertices of the geometric polytope.
Perhaps related: what are the local obstructions to being geometric?
The first two core, non-geometric triangulation we looked at had the
following sub-triangulation:
[(~1, ~a, b), (~b, 0, c), (~c, 1, d), (~d, e, ~0)]
which is a slit torus. :) Note that the edges b and d are forward and
backward flippable. So to be geometric we must have
y_1 + y_c > x_b = x_c + x_0 (for b)
and
y_1 + y_c = y_d < x_c + x_0 (for d)
which is a contradiction.
What is the frequency of this subtriangulation among all core
triangulations? We want to show that it is positive, and thus the
non-geometric core triangulations have a strictly faster exponential
growth rate than the geometric ones... Compare to the probability that
a permutation contains a two-cycle of the form (k k+1) (which gives a
slit torus in the corresponding square-tiled surface, etc).
2018-08-22
- Note that our automaton has two symmetries, not four, due to the way
we are allowing core triangulations. That is: Suppose that T is
geometric. Suppose that there are three edges, all automorphically
equivalent, and all forward flippable. So T will have three forward
edges to T'. Now, T' will be core, and will have two forward flips
to T''_0 and T''_1 (say) which will each have one forward flip to S,
again geometric.... So we don't get all of the automorphisms we
"deserve". The geometric polytope will work, however...
- Question: How can we walk forwards to a cylinder decomposition? Is
there a greedy geometric algorithm?
- Question: Can we put a pole at the center of an edge? Ie can we
fold edges about poles? If so, what happens to the permutations???
It seems that there is a difference between marked poles (needed for
Q(-1^4)) and regular poles. It seems that this is not impossible to
implement -- and it does not kill the Royal Automaton... I think.
What do the train tracks look like? I think that they just have
stops... so it is fine.
TODO: Abelian differentials should layout correctly (in order to avoid
trouble, just fix signs in the constructor)
2018-08-21 [Vincent, Saul]
Random thoughts:
- Can we do flips in a more general context? Ie, if you have two
polytopes P and Q adjacent to each other along e, then look at the
edges in P and Q adjacent to e. If in P we see R^k.e.B^\ell and
similarly in Q then we should be able to do the forward flip, by
moving both endpoints of e just one edge anti-clockwise. Hmm. I
guess that the above condition is the same as requiring that P
\cup_e Q is convex.
- Vincent says that there should be a way to prevent the commutivity.
That is, there should be an automaton where each pA map is
represented by a unique loop... He and CU did this for hyp
strata - in fact there every pA is uniquely a product of partial
Dehn twists. This is super cool. The converse is surely (?) false.
[Saul: This result does sound a bit like my result with Henry about pA
flows?]
Question:
- The vertices of the vertical and horizontal polytopes are vertex
cycles, aka low weight curves... What do the vertices of the
geometric polytope mean? How can we find one quickly?
[2018-08-22 Vincent says - Such vertices can have lots of area zero
triangles, so they are difficult to plot... Saul replies - add a
very small amount of the middle of the polytope to "blow in a bit of
air" so we can look at it...]
- Idea - use linear programming to decide if the geometric polytope is
the correct dimension.
New features:
- better "good_starts" using the face permutation.
(Decided against using v.e.f = [2, 1; 1, 1] as it is too slow.)
- input from strings
- automorphisms!
TODO:
[See also 2018-07-09]
- detect component of stratum (hyp/even/odd in abelian case and reg/irr in quad)
- cylinders and cylinder decompositions
- use cylinders for layout
2018-08-19 [Vincent, Saul]
The code to generate automata was too slow because of two reasons:
- A new triangulation is computed for each edge. That can be avoided
by making inplace flips. flipper Triangulation is not well
adapted to this and we reimplemented a simpler datastructure
in triangulation.py.
- it is not necessary to compute polytopes in order to know if a flip
is valid. It is enough to look for curves that gives appropriate
weight. This is implemented in the method edge_has_curve of
ColouredTriangulation.
New features:
- flat layout + pictures of flat triangulations with train-tracks
- write a simple setup.py to simplify installation
- avoid polytope constructions
2018-08-15
Here are two nice coloured triangulations that differ by a reflection
about x = y:
sage: import flipper
sage: Tri1 = [(~0r, 1r, ~4r),(~1r, 4r, 2r),(~2r, 3r, ~5r),(~3r, 5r, 0r)]
sage: Tri2 = [(0r, 5r, ~3r), (3r, ~2r, ~5r), (2r, 4r, ~1r), (1r, ~0r, ~4r)]
sage: from constants import *
sage: colours = [RED]*4 + [BLUE]*2
sage: import colouredtriangulation
sage: CT1 = colouredtriangulation.ColouredTriangulation(T1, colours)
sage: CT2 = colouredtriangulation.ColouredTriangulation(T2, colours)
sage: CT1.iso_sig()
'RRBRBR_acbdlefjkghi'
sage: CT2.iso_sig()
'RRBRBR_acbdfjeklghi'
So the code correctly sees that these are not isomorphic via an
orientation preserving isomorphism.
2018-07-10
Facts:
The codimension one faces of the (normalised) geometric polytope can
arise from a degeneration of the Keane condition. Very sad. But
these are easy to detect and avoid using the centre - just check for
zeros.
[2018-08-15: Ian Frankel points out: A Keane face may be subdivided
into infinitely many faces... these should fall into nicely modular
families that differ by Dehn twists parallel to the edge with the
"degenerating" coordinate.]
Not all polytopes have the same number of flippable faces.
There are polytopes where the flippable faces have supports of
different sizes.
In a hyperelliptic stratum there can be polyopes with flippable faces
with support being a single saddle connection. That's cool!
(I assume that the saddle connection runs through a Weierstrass point...(SS))
Question:
The current version uses the centre for everything - is there a way to
avoid this? Why is it so slow?
Conjectures:
Different flippable faces of the (normalised) geometric polytope have
"disjoint support" - a saddle connection is involved in at most one
multiflip. (If true, this gives a strong upper bound on the number of
faces...)
In a multiflip all of the saddle connections have the same colour
before, and have the same colour after. (Surely this follows from
M-parallelism.)
In strata, multiflips have size one or two... (Ask Saul why he thought
this might be true... It is definitely false in more special orbit
closures)
2018-07-09
Current wish-list for Veerer:
0. Detect hyperelliptic, spin
1. Build the geometric automaton.
2. Zorich acceleration.
3. Linear subvarieties.
4. Splitting zeros.
Applications - look for separators (good cuts) of the geometric
automaton. Use that to prove a spectral gap.
2018-06-30
Vincent asks: Can we modify veerer to allow poles in the centers of
edges?
This is very, very similar to Ian's desire -- see the discussion on
2015-09-06. However, this completely breaks flippers underlying data
structure for triangulations. So this is not going to happen.
One wonders if the heavier data structure (where you have triangles
and edge gluings instead of triples of edges) is paid back for by the
reduction in size of the automaton?
Here is a more serious objection than "flipper does not work that
way": If we want to have a chance at splitting poles off of zeros (or
merging them with) then we need the poles at vertices.
Another objection: All of the proofs are in terms of empty
squares... The symmetric bigons around a pole are pretty, but I don't
think that justifies doubling the lengths of all of the proofs???
2018-06-29
Chatting with Curt:
1. You should implement carrying around a linear subspace. Bite the
bullet and deal with number fields.
2. You should implement carrying around a quadratic condition (as
sometimes those can be defined over \ZZ and you won't have to pay the
cost of the number field). [I actually do not understand this - I
thought that being an eigenvector is a linear condition? Ok, but not
over \QQ.]
3. If you start at a ramdom triangulation, with a random linear space,
you can perhaps prove that it won't terminate by finding a nice loop
(that moves you further and further into the corner of some polytope).
4. Using (1), compute generating matrices for Veech groups. Compute
Euler characteristics for Veech curves... There are conjectures (about
growth of square-tiled surfaces) that could be supported or falsified
this way. Of course we want this in higher dimension as well, but
start small.
[This is dumb, or very subtle, or both... all Euler characteristics
are zero because the parameter space is a circle bundle - we are
allowed to rotate! The SO(2) action is going to be very difficult to
remove, so... sorry, we cannot do this. Obtaining matrices still seems
possible for Veech groups. Try this for the golden table?]
2017-12-22
"Core ==> Geometric" was caused by a bug in the geometric dimension
code (MB).
2016-12-06
Limited experiments suggest that core (full horizontal and vertical
dimension) ==> geometric (full geometric dimension). This seem
super-unlikely to me (SS).