flipper.kernel.lamination.Lamination

class flipper.kernel.lamination.Lamination(triangulation, geometric, algebraic)

Bases: object

This represents a lamination on an triangulation.

It is given by a list of its geometric intersection numbers and a list of its algebraic intersection numbers with the (oriented) edges of underlying triangulation. Note that:

    ^ L
    |
----|----> e
    |

has algebraic intersection +1.

Users should use Triangulation.lamination() to create laminations with, when the lamination is a curve, its algebraic intersection computed automatically.

If remove_peripheral is True then the Lamination is allowed to rescale its weights (by a factor of 2) in order to remove any peripheral components / satifsy the triangle inequalities.

all_projective_isometries(other)

Return a list of isometries taking this lamination projectively to other.

collapse_trivial_weight(edge_index)

Return this lamination on the triangulation obtained by collapsing edge edge_index and an encoding which is at least algebraically correct.

Assumes (and checks) that:

• edge_index is a flippable edge,
• self.triangulation is not S_{0,3},
• the given edge does not connect between two unfilled vertices, and
• edge_index is the only edge of weight 0.

conjugate_short()

Return an encoding which maps this lamination to a lamination with as little weight as possible.

This lamination must be a multicurve.

dual_weights_doubled(corner)

Return the list of dual weights (doubled) associated to a corner.

encode_halftwist(k=1)

Return an Encoding of a left half twist about this lamination raised to the power k.

This lamination must be a half-twistable curve.

encode_twist(k=1)

Return an Encoding of a left Dehn twist about this lamination raised to the power k.

This lamination must be a twistable curve.

geometric_intersection(lamination)

Return the geometric intersection number between this lamination and the given one.

Assumes (and checks) that this is a twistable lamination.

is_bipod(corner)

Return if the lamination looks like a bipod with respect to the given corner.

is_curve()

Return if this lamination is a curve.

is_empty()

Return if this lamination is equal to the empty lamination.

is_halftwistable()

Return if this lamination is a half twistable curve.

is_homologous_to(other, relative_boundary=False)

Return if this lamination is homologous to the given one.

The the homology class is computed relative to the filled punctures, unless relative_boundary is set to True in which case it is done relative to all vertices.

This lamination and the given one must be defined on the same triangulation.

is_monopod(corner)

Return if the lamination looks like a monopod with respect to the given corner.

is_multicurve()

Return if this lamination is a multicurve.

is_nullpod(corner)

Return if the lamination looks like a nullpod with respect to the given corner.

is_orientable()

Return if the underlying train track of this lamination is orientable.

is_tripod(triangle)

Return if the lamination looks like a tripod in this triangle.

is_twistable()

Return if this lamination is a twistable curve.

isometries_to(other)

Return a list of isometries taking this lamination to other.

projective_hash(precision=30)

Return a hashable object that is invariant under isometries and rescaling.

projectively_equal(other)

Return if this lamination is projectively equal to other.

Other must be on the same Triangulation as this lamination.

puncture_tripods()

Return the encoding corresponding to puncturing the tripods of this lamination.

self_isometries()

Returns a list of isometries taking this lamination to itself.

splitting_sequences(dilatation=None, maxlen=None)

Return a list of splitting sequence associated to this lamination.

This is the encoding obtained by flipping edges to repeatedly split the branches of the corresponding train track with maximal weight until you reach a projectively periodic sequence (with the required dilatation if given).

Assumes that this lamination is projectively invariant under some mapping class. Assumes (and checks) that this lamination is filling.

Each entry of self.geometric must be an Integer or a RealAlgebraic (over the same RealNumberField).

stratum()

Return a dictionary mapping each vertex of the underlying triangulation to the number of stratum exiting it.

This is the number of bipods incident to the vertex.

tripod_regions()

Return a list of all triangles in which this lamination looks like a tripod.

weight()

Return the sum of the geometric intersection numbers of this lamination.