curver.kernel.lamination module

A module for representing laminations on Triangulations.

class curver.kernel.lamination.Lamination(triangulation, geometric)

Bases: object

This represents an (integral) lamination on a triangulation.

Users should create these via Triangulation(…) or Triangulation.lamination(…).

boundary()

Return the boundary of a regular neighbourhood of this lamination.

components()

Return a dictionary mapping components to their multiplicities.

dual_weight(edge)

Return the number of component of this lamination dual to the given edge.

Note that when there is a terminal normal arc then we record this weight with a negative sign.

fills_with(other)

Return whether self cup other fills.

intersection(lamination)

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

is_arc()

Return if this lamination is actually a multiarc.

is_curve()

Return if this lamination is actually a curve.

is_empty()

Return if this lamination has no components.

is_filling()

Return if this Lamination fills the surface, that is, if it intersects all curves on the surface.

Note that this is equivalent to:

• it meets every non S_{0,3} component of the surface, and
• its boundary is peripheral.

Furthermore, if any component of this lamination is a non-peripheral curve then it cannot fill.

is_multiarc()

Return if this lamination is actually a multiarc.

is_multicurve()

Return if this lamination is actually a multicurve.

is_peripheral()

Return whether this lamination consists entirely of parallel components.

is_short()

Return whether this lamination is short.

A lamination is short if all of its non-peripheral components are parallel to edges of the triangulation that it is defined on. This makes computing its components very easy.

multiarc()

Return the maximal MultiArc contained within this lamination.

multicurve()

Return the maximal MultiCurve contained within this lamination.

no_common_component(lamination)

Return that self does not share any components with the given Lamination.

non_peripheral(promote=True)

Return the lamination consisting of the non-peripheral components of this Lamination.

num_components()

Return the total number of components.

parallel_components()

Return a dictionary mapping component |–> (multiplicity, edge) for each component of self that is parallel to an edge.

peek_component()

Return one component of this Lamination.

peripheral(promote=True)

Return the lamination consisting of the peripheral components of this Lamination.

peripheral_components()

Return a dictionary mapping component |–> (multiplicity, vertex) for each component of self that is peripheral around a vertex.

promote()

Return this lamination in its finest form.

shorten()

Return an encoding which maps this lamination to a short one.

side_weight(edge)

Return the number of component of this lamination dual to the given edge.

Note that when there is a terminal normal arc then we record this weight with a negative sign.

skeleton()

Return the lamination obtained by collapsing parallel components.

sublaminations()

Return all sublaminations that appear within self.

topological_type()

Return the topological type of this lamination..

Two laminations are in the same mapping class group orbit if and only their topological types are equal. These are labelled graphs and so equal means ‘label isomorphic’, so we return a custom class that uses networkx.is_isomorphic to determine equality.

trace(edge, intersection_point, length)

Return the sequence of edges encountered by following along this lamination.

We start at the given edge and intersection point for the specified number of steps. However we terminate early if the lamination closes up before this number of steps is completed.

weight()

Return the geometric intersection of this lamination with its underlying triangulation.