curver.kernel.curve.Curve¶

class
curver.kernel.curve.
Curve
(triangulation, geometric)[source]¶ Bases:
curver.kernel.curve.MultiCurve
A MultiCurve with a single component.

boundary
()¶ Return the boundary of a regular neighbourhood of this lamination.

boundary_union
(other)¶ Return partial N(self cup other).

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.

encode_twist
(power=1)¶ Return an Encoding of a right Dehn (multi)twist about the components of this multicurve, raised to the given power.

fills_with
(other)¶ Return whether self cup other fills.

intersection
(*laminations)¶ Return the geometric intersection number between this lamination and the given one(s).
If multiple laminations are given then
sum(i(self, lamination) for laminations)
is returned.

is_empty
()¶ Return whether this lamination has no components.

is_filling
()¶ Return whether this IntegralLamination 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 nonperipheral curve then it cannot fill.

is_integral
()¶ Return whether this lamination is integral.

is_non_peripheral
()¶ Return whether this lamination does not have any peripheral components.

is_peripheral
()¶ Return whether this lamination consists entirely of peripheral components.

is_polygonalisation
()¶ Return whether this IntegralLamination is a polygonalisation, that is, if it cuts the surface into polygons.

is_separating
()¶ Return whether this multicurve separates S.
That is, whether S  self has more components than S.

is_short
()[source]¶ Return whether this lamination is short.
A lamination is short if all of its nonperipheral components are parallel to edges of the triangulation that it is defined on. This makes computing its components very easy.

left_weight
(edge)¶ Return the number of component of this lamination dual to the left of the given edge.
Note that when there is a terminal normal arc then we record this weight with a negative sign.

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 IntegralLamination.

non_peripheral
(promote=True)¶ Return the lamination consisting of the nonperipheral components of this Lamination.

num_components
()¶ Return the total number of components.

parallel
()[source]¶ Return an edge that this curve is parallel to.
Note that this is only defined for short, nonperipheral curves.

parallel_components
()¶ Return a dictionary mapping component to (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 to (multiplicity, vertex) for each component of self that is peripheral around a vertex.

promote
()¶ Return this lamination in its finest form.

relative_twisting
(b, c)[source]¶ Return the relative twisting number of b about self relative to c.
This is the number of (right) Dehn twists about self that must be applied to b in order to minimise its intersection with c.
This curve must be nonperipheral and intersect the given laminations.

right_weight
(edge)¶ Return the number of component of this lamination dual to the right the given edge.
Note that when there is a terminal normal arc then we record this weight with a negative sign.

shorten
(drop=0.1)¶  Return a pair (s, h) where:
 s is a short lamination of the correct class, and
 s = h(self)
In each round, we do not look for an accelerating Dehn twist if a flip can drop the weight by at least drop`%. So if `drop == 0.0 then acceleration is never done and this returns the Mosher flip sequence. As long as drop > 0 this method runs in poly(self) time.
The original version of this method was based on [Bell16] but now a simpler and more efficient technique is used. The argument why this version runs in polynomial time follows that of [EricksonNayyeri13].

skeleton
()¶ Return the lamination obtained by collapsing parallel components.

slope
(lamination)[source]¶ Return the slope of the given lamination about this curve.
This is a Fraction that increases by one each time a right Dehn twist about this curve is performed unless 1 <= slope <= 1.
This curve must be nonperipheral and intersect the given lamination.

sublaminations
()¶ Return all sublaminations that appear within self.

topological_type
(closed=False)¶ Return the topological type of this lamination.. If the closed flag is set the the object returned records the topological type of the lamination after applying the forgetful map.
Two laminations are in the same mapping class group orbit if and only their topological types are equal.

trace_curve
(edge, intersection, max_length)¶ Return the curve obtained by following along this lamination and closing up when you get back to this edge.
We start at the given edge and intersection point and only go for at most max_length. A ValueError is raised if:
 we do not get back to the starting edge within this number of steps,
 the lamination terminates into a vertex, or
 upon returning to start_edge we cannot close up without creating intersections.

vertex_cycle
()¶ Return a vertex cycle of this multicurve.

vertex_cycles
()¶ Yield the vertex cycles of this multicurve.
These are the curves that use the same normal arcs as this multicurve but only pass through each edge at most twice. Be careful as there are often a lot of them.

weight
()¶ Return the geometric intersection of this lamination with its underlying triangulation.
