Detect half-translation double cover

[videlec]

Given a translation surface (translation_surface.TranslationSurface), it is desirable to know whether it comes from the canonical double cover of a quadratic differential (half_translation_surface.HalfTranslationSurface). This can be done via Delaunay triangulations and isomorphism check which is implemented in libflatsurf. Some method should provide access to the combinatorics of the involution in order to determine the underlying stratum of half-translation surfaces.

Maybe it would be desirable to construct the quotient half-translation surface.

[wphooper]

We can currently compute if a suface admits an automorphism with derivative -I:

from flatsurf import *
from flatsurf.geometry.similarity_surface_generators import TranslationSurfaceGenerators
s = TranslationSurfaceGenerators.octagon_and_squares()
flipped_s = - identity_matrix(2) * s
s.canonicalize() == flipped_s.canonicalize()

You can find the combinatorics of the automorphism using the following:

s1 = TranslationSurfaceGenerators.arnoux_yoccoz(3).canonicalize()
s2 = - identity_matrix(2) * s1
cm = s2.canonicalize_mapping()
rim = cm.factors()[0] # Get the reindex mapping
rim._f

Here rim._f is a dictionary:

{0: 3, 1: 4, 2: 7, 3: 0, 4: 1, 5: 8, 6: 10, 7: 2, 8: 5, 9: 11, 10: 6, 11: 9}

It tells how labels are changed when canonicalizing. (Canonicalization does Delaunay, then canonicalizes polygons, and then relabels the polygons.)

This is not a complete solution. There presumably are translation surfaces with automorphisms with derivative -I that do not have involutions with derivative -I. Once you find one such automorphism, all the automorphisms with derivative -I are this one composed with a translation automorphism. Do we currently have a way to access the TranslationAutomorphism group? (These are all related issues!)

Is the "quotient half-translation surface" unique? Perhaps there are sometimes multiple involutions with derivative -I with distinct derivatives?

[videlec]

Indeed, it might not be unique! But all are equivalent up to the translation automorphism group (if you have two -I transformation their composition is a translation automorphism).

One example is provided by the surface from the windtree model with orientable Deck group Z/2 x Z/2 and has an extra Z / 2 for the -I derivative one. You get plenty of different quotients.

[videlec]

Thanks for detailing the feature. This is also implemented in libflatsurf now.

[saraedum]

So, I guess the missing task here is to fully expose this in sage-flatsurf?

[videlec]

Indeed. There are several relevant groups

• the group of automorphisms with derivative 1 ("translation")
• the group of automorphisms with derivative +1/-1 ("half-translation")
• the group of isometries For each of them, one can consider associated quotients and obtain TranslationSurface, HalfTranslationSurface or RationalConeSurface.

[videlec]

There is a bit of coding involved in this group computation : we want to end up with generators and not the full list of automorphisms. It should be possible to refine https://github.com/flatsurf/flatsurf/issues/287.

[wphooper]

I have some code that is very relevant for this that I haven't gotten around to polishing and pushing yet.

Basically, my students and I have some code which better does canonicalization. Currently, I guess we only have canonicalization for translation surfaces (unless you have implemented it somewhere else). Our code also allows you to compute automorphism groups (as a list, not as generators). Certainly it would be better to produce generators directly, but I'm not sure how to do this without making a list first.

Most generally, there is a similarity automorphism of a similarity surface. You can also look at dilation automorphisms of a dilation surface.

I assume that if we have multiple algorithms for something, we can just include a keyword parameter enabling the user to select the algorithm, right?

On Thu, Dec 9, 2021 at 12:20 AM Vincent Delecroix @.***> wrote:

There is a bit of coding involved in this group computation : we want to end up with generators and not the full list of automorphisms. It should be possible to refine flatsurf/flatsurf#287 https://github.com/flatsurf/flatsurf/issues/287.

— You are receiving this because you commented. Reply to this email directly, view it on GitHub https://github.com/flatsurf/sage-flatsurf/issues/75#issuecomment-989522787, or unsubscribe https://github.com/notifications/unsubscribe-auth/ABMKBJZWI5WQD2M6K7HKTDDUQA4AVANCNFSM4TVMHLEA . Triage notifications on the go with GitHub Mobile for iOS https://apps.apple.com/app/apple-store/id1477376905?ct=notification-email&mt=8&pt=524675 or Android https://play.google.com/store/apps/details?id=com.github.android&referrer=utm_campaign%3Dnotification-email%26utm_medium%3Demail%26utm_source%3Dgithub.

[saraedum]

I assume that if we have multiple algorithms for something, we can just include a keyword parameter enabling the user to select the algorithm, right?

That's how SageMath does this, yes.

[videlec]

Our code also allows you to compute automorphism groups (as a list, not as generators). Certainly it would be better to produce generators directly, but I'm not sure how to do this without making a list first.

From the code that produces a list, it is not hard to extract the (faster) code that produces only generators. The only subtle part is : given half-edge h1 and h2 is there an automorphism mapping h1 to h2?

The idea is that you start from the group G_0 = 1 and fix an arbitrary half-edge that I call the root. At each step you have G_n contained inside the automorphism group and a set of representatives of the orbits of G_n on the half-edges some of which are tagged "seen" and the other "unseen". At step 0, the representatives are all the half edges and only the root edge is tagged seen. To go to the step n+1, you pick one unseen representative, check whether there is an automorphism mapping the root half-edge to the representative. If there is such automorphism tau set G_{n+1} = <G_n, tau> and compute which representatives gets merged by adding this generator. If not, just tag this representative as "seen".

[saraedum]

We could this revisit this now that codes are implemented in libflatsurf.