bigger.lamination.Lamination¶

class
bigger.lamination.
Lamination
(triangulation: bigger.triangulation.Triangulation[~Edge][Edge], weight: Callable[[Edge], int], support: Callable[[], Iterable[Edge]])[source]¶ Bases:
typing.Generic
A measured lamination on a
Triangulation
.The lamination is defined via a function mapping the edges of its underlying Triangulation to their corresponding measure.

complexity
() → int[source]¶ Return the number of intersections between this Lamination and its underlying Triangulation.

components
() → dict[Lamination[Edge], int][source]¶ Return a dictionary mapping components to their multiplicities.

describe
(edges: Iterable[Edge]) → str[source]¶ Return a string describing this Lamination on the given edges.

draw
(edges: Optional[list[Edge]] = None, **options) → Image[source]¶ Return a PIL image of this Lamination around the given edges.

dual
(side: bigger.triangulation.Side[~Edge][Edge]) → int[source]¶ Return the weight of this lamination dual to the given side.

is_finitely_supported
() → bool[source]¶ Return whether this lamination is supported on finitely many edges of the underlying Triangulation.

left
(side: bigger.triangulation.Side[~Edge][Edge]) → int[source]¶ Return the dual weight to the left of this side.

meeting
(edge: Edge) → bigger.lamination.Lamination[~Edge][Edge][source]¶ Return the sublamination of self meeting the given edge.
Note: self does not need to be finitely supported but the sublamination must be. Unfortunately we have no way of knowing this in advance.

parallel_components
() → dict[Lamination[Edge], tuple[int, bigger.Side[Edge], bool]][source]¶ Return a dictionary mapping component to (multiplicity, side, is_arc) for each component of self that is parallel to an edge.

peripheral
() → bigger.lamination.Lamination[~Edge][Edge][source]¶ Return the lamination consisting of the peripheral components of this Lamination.

peripheral_components
() → dict[Lamination[Edge], tuple[int, list[bigger.Side[Edge]]]][source]¶ Return a dictionary mapping component to (multiplicity, vertex) for each component of self that is peripheral around a vertex.

right
(side: bigger.triangulation.Side[~Edge][Edge]) → int[source]¶ Return the dual weight to the right of this side.

shorten
() → tuple[bigger.Lamination[Edge], bigger.Encoding[Edge]][source]¶ Return an
Encoding
that maps self to a short lamination.

supporting_sides
() → Iterable[bigger.triangulation.Side[~Edge][Edge]][source]¶ Return the sides supporting this lamination.

supporting_triangles
() → set[bigger.triangulation.Triangle[Edge]][source]¶ Return a set of triangles supporting this lamination, useful for debugging.

trace
(side: bigger.Side[Edge], intersection: int) → Iterable[tuple[bigger.Side[Edge], int]][source]¶ Yield the intersections of the triangulation run over by this lamination from a starting point.
The starting point is specified by a Side and how many intersections into that side.

twist
(power: int = 1) → bigger.encoding.Encoding[~Edge][Edge][source]¶ Return an
Encoding
that performs a Dehn twist about this Lamination.Assumes but does not always check that this lamination is a multicurve.

twisted_by
(multicurve: bigger.lamination.Lamination[~Edge][Edge], power: int = 1) → bigger.lamination.Lamination[~Edge][Edge][source]¶ Return multicurve.twist()(self).
Assumes but does not check that multicurve is a multicurve. This is used purely for performance by allowing for memoization in self.twist.
