Sage flat surfaces wiki

Contents

  1. Sage flat surfaces wiki
  2. Flat surfaces in Sage
    1. What is a flat surface ? What are we doing here ?
    2. Links
  3. Global organization
    1. Architecture
    2. What should be a Sage flat surface ?
      1. Different representations/implementations for flat surfaces
      2. Needed generic methods
  4. Roadmap / Concrete tasks
    1. Wishes
    2. Interval exchange transformations
    3. Permutation in pure C
    4. Separatrix diagrams / Cylinder diagrams
    5. Origami
    6. Surface groups and mapping class group
      1. Surface group and covers
      2. Mapping class group
    7. Hyperbolic geometry
    8. Port of other programs

Flat surfaces in Sage

What is a flat surface ? What are we doing here ?

A flat surface can be seen either

This page is an organization wiki for the implementation of various algorithms related to flat surfaces and more generally geometry/combinatorics/dynamics of surfaces (mapping class group, train tracks, pseudo-Anosov dynamics, ...). If you have a special request do not hesitate to edit wishes.

Global organization

Architecture

We need to review the architecture of flat surfaces repository to fit with the general framework for dynamics. In is now as follows and should be quickly changed

What should be a Sage flat surface ?

We aim to allow different implementation for flat surfaces and full compatibility between them. Here is a draft of what we expect.

Different representations/implementations for flat surfaces

Needed generic methods

Roadmap / Concrete tasks

We need to rebase some of the code and create new one. Here is what do we want to be done.

Wishes

Write here what you need for your research work (no precision on implementations is needed).

Interval exchange transformations

Permutation in pure C

We really need fast permutation objects for various reason (and other group theoretical stuff). The most convenient would be to use GAP which is completely written in C and has a lot of capabilities to deal with permutations. Moreover, the implementation of permutation in GAP is as we expect: starting at 0 and not 1 

**  Mathematically a permutation is a bijective mapping  of a finite set onto
**  itself.  In \GAP\ this subset must always be of the form [ 1, 2, .., N ],
**  where N is at most $2^16$.
**
**  Internally a permutation  is viewed as a mapping  of [ 0,  1,  .., N-1 ],
**  because in C indexing of  arrays is done with the origin  0 instead of 1.
**  A permutation is represented by a bag of type 'T_PERM' of the form
**
**      +-------+-------+-------+-------+- - - -+-------+-------+
**      | image | image | image | image |       | image | image |
**      | of  0 | of  1 | of  2 | of  3 |       | of N-2| of N-1|
**      +-------+-------+-------+-------+- - - -+-------+-------+
**
**  The entries of the bag are of type  'UInt2'  (defined in 'system.h' as an
**  at least 16 bit   wide unsigned integer  type).   The first entry is  the
**  image of 0, the second is the image of 1, and so  on.  Thus, the entry at
**  C index <i> is the image of <i>, if we view the permutation as mapping of
**  [ 0, 1, 2, .., N-1 ] as described above.

Separatrix diagrams / Cylinder diagrams

Origami

Surface groups and mapping class group

They are needed from two points of view: the group of the surface itself and the flat surface's stabilizer under the action of SL(2,R) or PSL(2,R). There must be some software for dealing with surface groups. We need to look at

Surface group and covers

To deal with coverings we need some stuff about constellations (of genus g and degree d) which are (ordered) tuples of permutations (\alpha_i, \beta_i)_{i \in \{1, ldots, g\}} and (\delta_i)_{i \in \{1, \ldots, k\}} in the symmetric group S_d such that

A constellation has to be thought "up to conjugacy". For any tuple of permutations, one can compute a normal form for it in polynomial time. Most of the time, one would like to choose the conjugacy classes of the \delta_i and fix the degree of the cover. There exists explicit formula for counting involving Frobenius formula but is there any fast generation method ?

Mapping class group

Is there any library somewhere to work with the mapping class group?

Hyperbolic geometry

This part is roughly implemented in trac #9439

The Experimental geometry lab (University of Maryland) published a lot of Mathematica packages/worksheets to deal with Kleinian and Fuchsian groups, hyperbolic tessellations, etc.

Port of other programs