bigger.lamination.Lamination

class bigger.lamination.Lamination(triangulation: bigger.triangulation.Triangulation[~Edge][Edge], weight: Callable[[Edge], int], support: Callable[[], Iterable[Edge]])

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

Return the number of intersections between this Lamination and its underlying Triangulation.

components() → dict[Lamination[Edge], int]

Return a dictionary mapping components to their multiplicities.

describe(edges: Iterable[Edge]) → str

Return a string describing this Lamination on the given edges.

draw(edges: Optional[list[Edge]] = None, **options) → Image

Return a PIL image of this Lamination around the given edges.

dual(side: bigger.triangulation.Side[~Edge][Edge]) → int

Return the weight of this lamination dual to the given side.

intersection(*laminations) → int

Return the number of times that self intersects other.

is_finitely_supported() → bool

Return whether this lamination is supported on finitely many edges of the underlying Triangulation.

left(side: bigger.triangulation.Side[~Edge][Edge]) → int

Return the dual weight to the left of this side.

meeting(edge: Edge) → bigger.lamination.Lamination[~Edge][Edge]

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]]

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]

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

peripheral_components() → dict[Lamination[Edge], tuple[int, list[bigger.Side[Edge]]]]

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

Return the dual weight to the right of this side.

shorten() → tuple[bigger.Lamination[Edge], bigger.Encoding[Edge]]

Return an Encoding that maps self to a short lamination.

supporting_sides() → Iterable[bigger.triangulation.Side[~Edge][Edge]]

Return the sides supporting this lamination.

supporting_triangles() → set[bigger.triangulation.Triangle[Edge]]

Return a set of triangles supporting this lamination, useful for debugging.

trace(side: bigger.Side[Edge], intersection: int) → Iterable[tuple[bigger.Side[Edge], int]]

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]

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]

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.

unicorns(other: Lamination[Edge]) → set[Lamination[Edge]]

Return a set of arcs which contains all the unicorn arcs that can be made from self and other.

Note that it is possible that the set may also contain other non-unicorn arcs. Assumes that self is a multiarc.