Interval exchange transformations#

Introduction#

This file is a good entry point to learn how to use interval exchange transformations in surface-dynamics. Recall that an interval exchange transformation is a piecewise translation of an interval. It can be encoded by a pair \((\pi, \lambda)\) where \(\pi\) is a permutation and \(\lambda\) is a vector of positive real numbers. These are respectively called the combinatorial datum and the length datum of the interval exchange transformation.

Building an interval exchange transformation and simple manipulations#

Here is an example of interval exchange transformation on 4 subintervals with rational lengths

from surface_dynamics import iet
perm = iet.Permutation('a b c d', 'd c b a')
length = [1/3, 2/7, 4/13, 5/19]
t = iet.IntervalExchangeTransformation(perm, length)
print(t)

Interval exchange transformation of [0, 6172/5187[ with permutation
a b c d
d c b a

It can be visualized with:

G = t.plot_function()
G.set_aspect_ratio(1)
G # random (matplotlib warning in conda)
t.plot_two_intervals()
../_images/3bfa880b1911d463dbe93c851e753089e95ee4dc20b30112d72da6917e278ff2.png

Given a point in the interval \([0, 6172/5187[\) it is possible to compute its image under the map \(t\)

x = 1/12
t(x)

19501/20748

To know which translation has been applied to the point \(x\) you can use

print(t.in_which_interval(x))
print(t.translations())
print(x + t.translations()[0] == t(x))

a
(1481/1729, 176/741, -142/399, -253/273)
True

Can you compute the first 20 elements of the orbit of \(x\), that is the sequence \((x, t(x), t^2(x), \ldots, t^{19}(x))\)?

Can you determine whether the orbit of :math:x is periodic, that is whether there exists \(n > 0\) such that \(t^n(x) = x\)?

To construct an interval exchange on other numbers than rationals you need to manipulate exact real numbers. The current sage version (9.2) only supports computation with algebraic numbers such as

x = polygen(QQ)
K.<sqrt2> = NumberField(x^2 - 2, embedding=AA(2).sqrt())
length2 = [1, sqrt2, sqrt2**2, sqrt2**3]
t2 = iet.IntervalExchangeTransformation(perm, length2)
print(t2)

Interval exchange transformation of [0, 3*sqrt2 + 3[ with permutation
a b c d
d c b a

Rauzy induction and self-similar iet#

Rauzy induction is a map from the space of interval exchange transformations to itself. The image \(\mathcal{R}(t)\) of an iet \(t\) is an induced map.

t3 = t2.rauzy_move()
r = max(set(flatten(t2.singularities())) - set([0,3*sqrt2+3]))
G = t2.plot_two_intervals() + t3.plot_two_intervals(position=(0,-.8))
G += line2d([(r, -1.), (r, .2)], color='black', linestyle='dotted')
G.axes(False)
G
../_images/0b9f076a320545ba8a3ad57a884d7196fec0c5d5f18147a5e51a46fcb60f5533.png

From a flip sequence given combinatorially you can build the associated self-similar interval exchange transformation

R = perm.rauzy_diagram()
G = R.graph()
P = G.plot(color_by_label=True, edge_labels=True, vertex_size=800)
P
../_images/66572c8d61c578bbefeac9f53cca11998c6c917e078c0a1171ea1bdcc82dffaf.png 
seq = ['t', 'b', 't', 'b', 't', 't', 'b', 'b', 't', 'b']
f = iet.FlipSequence(perm, seq)
print(f.is_loop())
print(f.is_full())

True
True

dilatation, t4 = f.self_similar_iet()
print(dilatation, '~', dilatation.n())

3*a + 2 ~ 6.85410196624968

Above dilatation is the expansion of the self-similarity and t4 is the self-similar exchange transformation associated to the flip sequence f

t5 = t4.rauzy_move(iterations=len(seq))
G = t4.plot() + t5.plot(position=(0,-.5))
G.axes(False)
G
../_images/8b6288ddfaa66928148ea099c01b7bd60168a86f0b114774e9a4c6390be625bd.png 
print(t4.lengths())
print(t5.lengths())
print(dilatation * t5.lengths() == t4.lengths())

(1, 6/5*a + 2/5, 3/5*a + 1/5, 6/5*a + 2/5)
(-3*a + 5, 6/5*a - 8/5, 3/5*a - 4/5, 6/5*a - 8/5)
True

The command below checks that t4 is indeed self induced

print(t4.normalize() == t5.normalize())

True

Suspension#

sage-flatsurf is a Python library for translation surfaces (and more generally similarity surfaces). One can build Masur polygons via

height = [1, 0, 0, -1]
S = perm.masur_polygon(length2, height)
S
S.stratum()

H_2(2)

Could you construct a self-similar translation surface from the flip sequence f? (in other words a translation surface that admits a pseudo-Anosov preserving the horizontal and vertical foliations)

Using pyintervalxt#

intervalxt is a C++ library with a Python interface that implements optimized routines to deal with interval exchange transformations. If intervalxt is part of your installation you can convert interval exchange transformations back and forth between surface-dynamics and pyintervalxt

from surface_dynamics.interval_exchanges.conversion import iet_to_pyintervalxt, iet_from_pyintervalxt
u2 = iet_to_pyintervalxt(t2)
print(u2)
v2 = iet_from_pyintervalxt(u2)
print(v2)

(Re-)building pre-compiled headers (options: -O2 -march=native); this may take a minute ...

/usr/share/miniconda3/envs/test/lib/python3.10/site-packages/cppyy/__init__.py:341: DeprecationWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html
  import pkg_resources as pr
/tmp/ipykernel_5488/1501804959.py:2: DeprecationWarning: the function is_NumberField is deprecated; use isinstance(x, sage.rings.number_field.number_field_base.NumberField) instead
See https://github.com/sagemath/sage/issues/35283 for details.
  u2 = iet_to_pyintervalxt(t2)

[a: 1] [b: (sqrt2 ~ 1.4142136)] [c: 2] [d: (2*sqrt2 ~ 2.8284271)] / [d] [c] [b] [a]
Interval exchange transformation of [0, 3*sqrt2 + 3[ with permutation
a b c d
d c b a

One feature of intervalxt is that it can certify that an iet has no periodic trajectory

u2.boshernitzanNoPeriodicTrajectory()

True

Other features#

This short tour did not exhaust all the possibilities of surface-dynamics, in particular

  • iet statistics (in surface_dynamics.interval_exchanges.integer_iet)

  • linear families of iet (in surface_dynamics.interval_exchanges.iet_family)

  • coverings and Lyapunov exponents of the Kontsevich-Zorich cocycle

These topics might be included in later versions of this document.

Missing features#

  • generalizations (linear involution associated to generalized permutations, interval exchange transformations with flips, affine iet, system of isometries)

  • Veech zippered rectangle construction

  • constructing the self-similar surface (aka pseudo-Anosov) associated to a flip sequence

If you are interested in developing any of these or have any request, get in touch with us at https://github.com/flatsurf/surface-dynamics