Algebraic clasp insertion in PD-codes #

The code-level tangle replacement underlying the second Reidemeister move creates two crossings at which the same strand is over. On a PD-code with n crossings, TauCeti.PDCode.insertClasp D p q b hqp hqe performs this algebraic clasp insertion on two distinct arcs: the arc P ending at the half-edge p and the arc Q ending at the half-edge q. Both arcs are cut open and routed through the two new crossings. These are the last two, (Fin.last n).castSucc (the first crossing, reached from p and q) and Fin.last (n + 1) (the second crossing, reached from the other ends of the two arcs).

With the slots of a crossing in counterclockwise order, the strand along P occupies slots 0 and 2 of the first crossing and slots 1 and 3 of the second, and the strand along Q occupies slots 1 and 3 of the first crossing and slots 0 and 2 of the second. The arcs are: p to slot 0 and q to slot 1 of the first crossing; slot 3 of the second crossing to the other end of P and slot 2 to the other end of Q; and the two short arcs of the clasp, from slot 2 of the first crossing to slot 1 of the second (along P) and from slot 3 of the first crossing to slot 0 of the second (along Q). The Boolean b is the over-pair indicator of the first crossing, and the second crossing gets !b, so that the same strand is over at both: with b = false it is the strand along P.

Of the four ways to smooth the two new crossings, one smooths them back into the two original arcs. The other three all reconnect the cut ends instead, p to q and the other end of P to the other end of Q, and one of these three also cuts off the circle through the two short arcs of the clasp. The first state and the circle-cutting one carry weight 1 in the Kauffman bracket, and the other two weights a ^ 2 and a⁻¹ ^ 2; since a ^ 2 + a⁻¹ ^ 2 + δ = 0 for the loop value δ = -(a ^ 2 + a⁻¹ ^ 2), the reconnected terms cancel, so the clasp insertion leaves the Kauffman bracket invariant. The insertion also keeps the number of components.

On its own the insertion is an algebraic operation on the code: nothing forces the two arcs to border a common region of the diagram. An arc borders a face of TauCeti.PDCode.face on each side, the face at each of its two ends: P borders the faces at p and at D.edgePair.val p. Going round the clasp counterclockwise, its four outer ends are met in the order p, q, D.edgePair.val q, D.edgePair.val p, so it can be drawn inside a face bordered by both arcs when the face at the far end D.edgePair.val p of P is the face at q, that is, when P and Q border a common face on the side of D.edgePair.val p and of q respectively. Every common face of the two arcs is of this form for a suitable choice of the ends passed as p and q; for instance, passing D.edgePair.val q instead of q uses the other side of Q. Under this face condition the insertion is the second Reidemeister move: the clasp cuts that face in two and adds the bigon between its two crossings, so the code gets two more faces (TauCeti.PDCode.faceCount_insertClasp_of_face_eq), its underlying graph keeps its connected components, and it is planar exactly when D is (TauCeti.PDCode.isPlanar_insertClasp_iff). The face condition cannot be dropped: if the two arcs lie in one connected component but the face at D.edgePair.val p is not the face at q, the clasp joins two faces into one, which its bigon only makes up for, and the new code is never planar (TauCeti.PDCode.not_isPlanar_insertClasp_of_face_ne). The insertion applies only to codes with a crossing; an insertion involving a crossing-free circle is not treated here.

Main definitions #

TauCeti.PDCode.insertClasp: algebraically insert a two-crossing clasp into two arcs.

Main results #

TauCeti.PDCode.crossingComponentCount_insertClasp: the insertion keeps the number of components.
TauCeti.PDCode.kauffmanBracket_insertClasp: the insertion leaves the Kauffman bracket unchanged.
TauCeti.PDCode.mirror_insertClasp: mirroring the new code inserts the clasp with the other strand over into the mirror code.
TauCeti.PDCode.faceCount_insertClasp_of_face_eq and TauCeti.PDCode.faceCount_insertClasp_of_face_ne: the insertion adds two faces when the face at D.edgePair.val p is the face at q, and none otherwise.
TauCeti.PDCode.card_monodromyOrbit_insertClasp: the insertion keeps the connected components of the underlying graph when the two arcs lie in one of them.
TauCeti.PDCode.isPlanar_insertClasp_iff: when the face at D.edgePair.val p is the face at q, the clasp keeps the code planar, and TauCeti.PDCode.not_isPlanar_insertClasp_of_face_ne: otherwise, between arcs of one component, it never yields a planar code.

References #

L. H. Kauffman, State models and the Jones polynomial, Topology 26 (1987), 395-407.
W. B. R. Lickorish, An Introduction to Knot Theory, Springer GTM 175 (1997), Chapter 1 (the Reidemeister moves) and Chapter 3, Lemma 3.3 (the bracket under the second move).
M. Mastin, Links and Planar Diagram Codes, Definitions 2-3 (the PD convention).

The arcs of a clasp, on the old half-edges and the slots of two new crossings #

A clasp's arcs are built as an involution of (α ⊕ Fin 4) ⊕ Fin 4: α holds the old half-edges, the middle Fin 4 the slots of the first new crossing, and the last Fin 4 those of the second. With e the old arcs, the arcs from p to e p and from q to e q are cut and routed through the slots. These helpers serve only the proofs in this file.

Following the new crossings #

Each way of reconnecting the eight new slots, after the arcs of the clasp, is an old traversal with the new slots spliced in. Written as a product of transpositions, each splice removes one orbit, which is how the orbits are counted below.