Documentation

LeanPool.RegtsSevenster.RS.Novel.Skein.RSTensor

The fragment tensor #

RS21 attaches to a fragment, an Eulerian subset, an Eulerian orientation and a compatible local pairing the tensor

t′_h(F,H,ω,κ) := Σ_χ t′_{h,χ}(F,H,ω,κ),

t′_{h,χ} := (−1)^{c-hat(κ)} Σ_{ψ ∼ χ₀, φ ∼ χ₁}
              ∏_{v ∈ V′(F)} h_v( … ) ⊗_{i ∈ [t]} c_{χ,ω,i}.

A basis coordinate of the tensor determines χ: an entering leg carries f_{χ₁(i)}, so its coordinate is χ₁(i) itself, and a leaving leg carries g_{χ₁(i)}, whose expansion is the partner colour with the partner sign. So the sum over χ collapses, and the coordinate at x is the colourings' sum read at untwist x, weighted by the leaving legs' signs.

The tensor is zero at a coordinate whose parity pattern is not the subset's, which is the condition that χ be consistent with S.

noncomputable def RS.EdgeSubset.tPrime {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (x : GenBoundaryState k ℓ α) :

RS21's tensor t′_h, in coordinates.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    noncomputable def RS.EdgeSubset.tPrimeD {α : Type} [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (tl : UsedLab F → Bool) (x : GenBoundaryState k ℓ α) :

    RS21's tensor at given arc directions. The chain orientation fixes the vertex signs; the arc directions fix which legs carry f and which carry g.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For

      The dual weight is a product of leg weights #

      The dual basis's weight is a product over the labels of a factor that depends only on that leg's colour and its arc's direction, so it is the leg weight the Gram computation uses. At a label the subset does not use, the colour is even and the factor is one.

      noncomputable def RS.EdgeSubset.legDir {α : Type} {W : Fragment α} (F : EdgeSubset W) (tl : UsedLab F → Bool) (i : α) :

      The arc direction as a function of the label, with the unused labels reading false.

      Equations
      Instances For
        theorem RS.EdgeSubset.dualWeightD_eq_prod_legWeight {α : Type} [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (tl : UsedLab F → Bool) (x : GenBoundaryState k ℓ α) (hx : genBoundarySubsetMatches W F.flags x) :
        dualWeightD F tl x = ∏ i : α, legWeight (F.legDir tl i) (x i)

        The dual weight is the product of the legs' weights.

        The normalised tensor #

        RS21 normalises by a fourth root of unity per two used legs and by the matching's sign:

        t_h(F,H,ω,κ) := (−1)^{|S|/4} · sgn(M(ω,κ)) · t′_h(F,H,ω,κ).
        

        Since |S| is only even, (−1)^{|S|/4} is a fourth root: i^{|S|/2}. The sign is taken against the reference matching with arcs (i₁,i₂),…, which is stdMatching on the used labels.

        @[reducible, inline]
        abbrev RS.EdgeSubset.UsedLabel {α : Type} {W : Fragment α} (F : EdgeSubset W) :

        The labels the subset uses — RS21's S(H).

        Equations
        Instances For

          The used labels are even in number: they are matched in pairs.

          noncomputable def RS.EdgeSubset.tFull {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (x : GenBoundaryState k ℓ α) :

          RS21's normalised tensor t_h, in coordinates.

          Equations
          Instances For

            The used labels are even in number, for any directed matching on them.

            noncomputable def RS.EdgeSubset.tFullD {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (M : DirMatching (UsedLab F)) (x : GenBoundaryState k ℓ α) :

            RS21's normalised tensor at given arc directions. The directions enter twice: through the matching's sign and through the dual basis.

            Equations
            Instances For
              theorem RS.EdgeSubset.tFull_eq_tFullD {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (x : GenBoundaryState k ℓ α) :
              F.tFull h κ o x = F.tFullD h κ o (cutMatching F κ o) x

              The normalised tensor is the directed one at the chain orientation's own directions.

              theorem RS.EdgeSubset.tPrimeD_eq_zero_of_not_throughAgree {α : Type} [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (tl : UsedLab F → Bool) (x : GenBoundaryState k ℓ α) (hbnd : genBoundarySubsetMatches W F.flags (untwistD F tl x)) (hag : ¬F.ThroughAgree (untwistD F tl x) hbnd) :
              F.tPrimeD h κ o tl x = 0

              A disagreeing state carries no colouring. RS21 colours a through-edge once, so a state whose two legs there disagree admits no φ ∼ χ₁, and the tensor vanishes at it.

              theorem RS.EdgeSubset.tPrime_eq_zero_of_not_throughAgree {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (x : GenBoundaryState k ℓ α) (hbnd : genBoundarySubsetMatches W F.flags (untwist F κ o x)) (hag : ¬F.ThroughAgree (untwist F κ o x) hbnd) :
              F.tPrime h κ o x = 0

              A disagreeing state carries no colouring, at the chain orientation's own directions.

              theorem RS.EdgeSubset.tFull_eq_zero_of_not_throughAgree {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (x : GenBoundaryState k ℓ α) (hbnd : genBoundarySubsetMatches W F.flags (untwist F κ o x)) (hag : ¬F.ThroughAgree (untwist F κ o x) hbnd) :
              F.tFull h κ o x = 0

              RS21's t_h vanishes at a disagreeing state.

              theorem RS.EdgeSubset.tFullD_eq_zero_of_not_throughAgree {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (M : DirMatching (UsedLab F)) (x : GenBoundaryState k ℓ α) (hbnd : genBoundarySubsetMatches W F.flags (untwistD F M.tail x)) (hag : ¬F.ThroughAgree (untwistD F M.tail x) hbnd) :
              F.tFullD h κ o M x = 0

              The normalised tensor vanishes at a disagreeing state.

              The tensor's support #

              The tensor vanishes unless the state's odd legs are exactly the labels the subset uses. On that support the number of odd legs is the number of used labels, and the legs whose arc leaves are half of them. These are the hypotheses RS21's leg count needs.

              theorem RS.EdgeSubset.genBoundarySubsetMatches_of_tPrimeD_ne_zero {α : Type} [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (tl : UsedLab F → Bool) (x : GenBoundaryState k ℓ α) (hne : F.tPrimeD h κ o tl x ≠ 0) :

              The tensor vanishes off its support.

              theorem RS.EdgeSubset.genBoundarySubsetMatches_of_tFullD_ne_zero {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (M : DirMatching (UsedLab F)) (x : GenBoundaryState k ℓ α) (hne : F.tFullD h κ o M x ≠ 0) :

              The same, for the normalised tensor.

              On the support the odd legs are the used labels.

              theorem RS.EdgeSubset.legDir_eq {α : Type} {W : Fragment α} (F : EdgeSubset W) (tl : UsedLab F → Bool) (i : α) (h : W.boundaryFlag i ∈ F.boundaryFlags) :
              F.legDir tl i = tl ⟨i, h⟩

              The leg direction agrees with the matching's on the used labels.

              theorem RS.EdgeSubset.untwistD_eq_untwistState {t : ℕ} {W : Fragment (Fin t)} (F : EdgeSubset W) {k ℓ : ℕ} (tl : UsedLab F → Bool) (x : GenBoundaryState k ℓ (Fin t)) :
              untwistD F tl x = untwistState (F.legDir tl) x

              The fragment's change of basis is the abstract one at its own leg directions.

              theorem RS.EdgeSubset.oddCount_eq_two_mul_legDir {t : ℕ} {W : Fragment (Fin t)} (F : EdgeSubset W) {k ℓ : ℕ} (x : GenBoundaryState k ℓ (Fin t)) (hx : genBoundarySubsetMatches W F.flags x) (M : DirMatching (UsedLab F)) :
              oddCount x = 2 * {i : Fin t | (∃ (c : Fin (2 * ℓ)), x i = Sum.inr c) ∧ F.legDir M.tail i = true}.card

              Half the used legs, in the form the leg count needs: the legs whose arc leaves are half the odd ones.

              theorem RS.EdgeSubset.tFullD_eq_zero_of_not_matches {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (M : DirMatching (UsedLab F)) (x : GenBoundaryState k ℓ α) (hx : ¬genBoundarySubsetMatches W F.flags x) :
              F.tFullD h κ o M x = 0

              The tensor vanishes off its support, read on the state itself rather than on its untwist.

              theorem RS.EdgeSubset.tFull_eq_zero_of_not_matches {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (x : GenBoundaryState k ℓ α) (hx : ¬genBoundarySubsetMatches W F.flags x) :
              F.tFull h κ o x = 0

              The normalised tensor vanishes off its support.

              The tensor over the core sum #

              RS21's colouring sum runs over every edge of the subset. By the bridge it equals the sum over the core edges, which is the vertex sum the mixed partition function is built from. So the tensor is the vertex sum, weighted by the circuit sign and the dual basis.

              theorem RS.EdgeSubset.tPrime_eq_vertexSum {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (x : GenBoundaryState k ℓ α) (hbnd : genBoundarySubsetMatches W F.flags (untwist F κ o x)) (hag : F.ThroughAgree (untwist F κ o x) hbnd) :
              F.tPrime h κ o x = (-1) ^ κ.openCircuitCount * dualWeight F κ o x * F.vertexSum h (untwist F κ o x) hbnd o

              The tensor is the vertex sum, weighted.

              theorem RS.EdgeSubset.tPrimeD_eq_vertexSum {α : Type} [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (tl : UsedLab F → Bool) (x : GenBoundaryState k ℓ α) (hbnd : genBoundarySubsetMatches W F.flags (untwistD F tl x)) (hag : F.ThroughAgree (untwistD F tl x) hbnd) :
              F.tPrimeD h κ o tl x = (-1) ^ κ.openCircuitCount * dualWeightD F tl x * F.vertexSum h (untwistD F tl x) hbnd o

              The tensor at given arc directions is the vertex sum, weighted.

              theorem RS.EdgeSubset.tFullD_eq {t : ℕ} {W : Fragment (Fin t)} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (M : DirMatching (UsedLab F)) (x : GenBoundaryState k ℓ (Fin t)) (hx : genBoundarySubsetMatches W F.flags x) (hag : F.ThroughAgree (untwistD F M.tail x) ⋯) :
              F.tFullD h κ o M x = Complex.I ^ (Fintype.card (UsedLab F) / 2) * ↑↑((DirMatching.stdMatching ⋯).sgnRel M) * (-1) ^ κ.openCircuitCount * ((∏ i : Fin t, legWeight (F.legDir M.tail i) (x i)) * F.vertexSum h (untwistD F M.tail x) ⋯ o)

              The tensor in the Gram computation's terms: a fourth root and the matching's sign, the circuit sign, the legs' weights, and the vertex sum at the untwisted state. Every factor but the last is what RS21's sign bookkeeping handles; the last is what the colouring sums multiply.

              The two fragments' vertex sums, paired #

              RS21's right-hand side is the composed graph's summand, whose colouring sum runs over V′(G) = V′(F₁) ⊔ V′(F₂). The object the Gram pairing produces is the two fragments' vertex sums multiplied at a shared interface state; naming it separates the sign bookkeeping from the colouring correspondence.

              noncomputable def RS.EdgeSubset.pairAgreeValue {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ₁ : F₁.RelTransitionSystem} (o₁ : κ₁.Orientation) {κ₂ : F₂.RelTransitionSystem} (o₂ : κ₂.Orientation) (st : GenBoundaryState k ℓ (Fin t)) :

              The two fragments' vertex sums at a shared agreeing state. RS21 colours a through-edge once, so a state whose two legs there disagree carries no colouring at all and both tensors vanish at it. The pairing therefore sees only the agreeing states, and it is this value, not the bare product of vertex sums, that it computes.

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For
                theorem RS.EdgeSubset.pairAgreeValue_pos {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ₁ : F₁.RelTransitionSystem} (o₁ : κ₁.Orientation) {κ₂ : F₂.RelTransitionSystem} (o₂ : κ₂.Orientation) (st : GenBoundaryState k ℓ (Fin t)) (h₁ : genBoundarySubsetMatches W₁ F₁.flags st) (h₂ : genBoundarySubsetMatches W₂ F₂.flags st) (hag₁ : F₁.ThroughAgree st h₁) (hag₂ : F₂.ThroughAgree st h₂) :
                F₁.pairAgreeValue F₂ h o₁ o₂ st = F₁.vertexSum h st h₁ o₁ * F₂.vertexSum h st h₂ o₂

                The agreeing value on its support is the two colouring sums.

                theorem RS.EdgeSubset.pairAgreeValue_eq_zero {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ₁ : F₁.RelTransitionSystem} (o₁ : κ₁.Orientation) {κ₂ : F₂.RelTransitionSystem} (o₂ : κ₂.Orientation) (st : GenBoundaryState k ℓ (Fin t)) (h₁ : ¬genBoundarySubsetMatches W₁ F₁.flags st) :
                F₁.pairAgreeValue F₂ h o₁ o₂ st = 0

                The agreeing value vanishes off the first tensor's support.

                theorem RS.EdgeSubset.pairAgreeValue_eq_zero_of_not_agree₁ {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ₁ : F₁.RelTransitionSystem} (o₁ : κ₁.Orientation) {κ₂ : F₂.RelTransitionSystem} (o₂ : κ₂.Orientation) (st : GenBoundaryState k ℓ (Fin t)) (h₁ : genBoundarySubsetMatches W₁ F₁.flags st) (hag : ¬F₁.ThroughAgree st h₁) :
                F₁.pairAgreeValue F₂ h o₁ o₂ st = 0

                The agreeing value vanishes where the first side disagrees.

                theorem RS.EdgeSubset.pairAgreeValue_eq_zero_of_not_agree₂ {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ₁ : F₁.RelTransitionSystem} (o₁ : κ₁.Orientation) {κ₂ : F₂.RelTransitionSystem} (o₂ : κ₂.Orientation) (st : GenBoundaryState k ℓ (Fin t)) (h₂ : genBoundarySubsetMatches W₂ F₂.flags st) (hag : ¬F₂.ThroughAgree st h₂) :
                F₁.pairAgreeValue F₂ h o₁ o₂ st = 0

                The agreeing value vanishes where the second side disagrees.

                theorem RS.EdgeSubset.pairAgreeValue_eq_edgeSum {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ₁ : F₁.RelTransitionSystem} (o₁ : κ₁.Orientation) {κ₂ : F₂.RelTransitionSystem} (o₂ : κ₂.Orientation) (st : GenBoundaryState k ℓ (Fin t)) (h₁ : genBoundarySubsetMatches W₁ F₁.flags st) (h₂ : genBoundarySubsetMatches W₂ F₂.flags st) :
                F₁.pairAgreeValue F₂ h o₁ o₂ st = F₁.edgeSum h st h₁ o₁ * F₂.edgeSum h st h₂ o₂

                The paired value is the two colouring sums, in RS21's own form. The agreement is not a condition imposed on top: it is the support of the colouring sum itself.

                theorem RS.EdgeSubset.superForm_mul_tFullD_mul_tFullD {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ₁ : F₁.RelTransitionSystem} (o₁ : κ₁.Orientation) (M₁ : DirMatching (UsedLab F₁)) {κ₂ : F₂.RelTransitionSystem} (o₂ : κ₂.Orientation) (M₂ : DirMatching (UsedLab F₂)) (x : GenBoundaryState k ℓ (Fin t)) (hx : genBoundarySubsetMatches W₁ F₁.flags x) (hag₁ : F₁.ThroughAgree (untwistD F₁ M₁.tail x) ⋯) (hx₂ : genBoundarySubsetMatches W₂ F₂.flags (dualState x)) (hag₂ : F₂.ThroughAgree (untwistD F₂ M₂.tail (dualState x)) ⋯) :
                (∏ i : Fin t, legSelf (x i)) * F₁.tFullD h κ₁ o₁ M₁ x * F₂.tFullD h κ₂ o₂ M₂ (dualState x) = ↑↑((DirMatching.stdMatching ⋯).sgnRel M₁) * (-1) ^ κ₁.openCircuitCount * (↑↑((DirMatching.stdMatching ⋯).sgnRel M₂) * (-1) ^ κ₂.openCircuitCount) * (Complex.I ^ (Fintype.card (UsedLab F₁) / 2) * Complex.I ^ (Fintype.card (UsedLab F₂) / 2) * ((∏ i : Fin t, legWeight (F₁.legDir M₁.tail i) (x i)) * ∏ i : Fin t, legWeight (F₂.legDir M₂.tail i) (dualLeg (x i))) * ∏ i : Fin t, legSelf (x i)) * (F₁.vertexSum h (untwistD F₁ M₁.tail x) ⋯ o₁ * F₂.vertexSum h (untwistD F₂ M₂.tail (dualState x)) ⋯ o₂)

                The Gram summand, per coordinate. At a coordinate the first tensor supports, the product of the two tensors against the form is the sign bookkeeping, the twists and leg weights the cancellation consumes, and the two vertex sums at the shared state.

                theorem RS.EdgeSubset.sum_sum_superForm_tFullD {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ₁ : F₁.RelTransitionSystem} (o₁ : κ₁.Orientation) (M₁ : DirMatching (UsedLab F₁)) {κ₂ : F₂.RelTransitionSystem} (o₂ : κ₂.Orientation) (M₂ : DirMatching (UsedLab F₂)) (m : ℕ) (hcard₁ : Fintype.card (UsedLab F₁) = 2 * m) (hcard₂ : Fintype.card (UsedLab F₂) = 2 * m) (hused : ∀ (i : Fin t), W₁.boundaryFlag i ∈ F₁.boundaryFlags ↔ W₂.boundaryFlag i ∈ F₂.boundaryFlags) (halt : ∀ (i : Fin t), W₁.boundaryFlag i ∈ F₁.boundaryFlags → F₂.legDir M₂.tail i = !F₁.legDir M₁.tail i) :
                ∑ x : GenBoundaryState k ℓ (Fin t), ∑ y : GenBoundaryState k ℓ (Fin t), superForm t x y * F₁.tFullD h κ₁ o₁ M₁ x * F₂.tFullD h κ₂ o₂ M₂ y = ↑↑((DirMatching.stdMatching ⋯).sgnRel M₁) * (-1) ^ κ₁.openCircuitCount * (↑↑((DirMatching.stdMatching ⋯).sgnRel M₂) * (-1) ^ κ₂.openCircuitCount) * ∑ st : GenBoundaryState k ℓ (Fin t), F₁.pairAgreeValue F₂ h o₁ o₂ st

                RS21's (13), up to its sign bookkeeping. The Gram pairing of the two fragments' tensors is the two colouring sums, multiplied at a shared interface state and summed, times the two matchings' signs and circuit signs. What remains to identify it with the composed graph's summand is (14) and the colouring correspondence.

                The vertex sum under a chain flip #

                The colouring sum's own chain-flip ledger, read on the vertex sum.

                theorem RS.EdgeSubset.vertexSum_portFlip {α : Type} {W : Fragment α} {F : EdgeSubset W} {κ : F.RelTransitionSystem} {S : Finset W.Flag} {p₁ p₂ : W.Flag} {i₁ i₂ : α} (hp : PortedFlipSet κ S p₁ p₂ i₁ i₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (st : GenBoundaryState k ℓ α) (hbnd : genBoundarySubsetMatches W F.flags st) {c₁ c₂ : Fin (2 * ℓ)} (hc₁ : st i₁ = Sum.inr c₁) (hc₂ : st i₂ = Sum.inr c₂) (o : κ.Orientation) :
                F.vertexSum h st hbnd (o.portFlip hp) = ↑(oddPartnerSign ℓ c₁ * oddPartnerSign ℓ c₂) * F.vertexSum h (stateOddFlip st i₁ i₂) ⋯ o

                The vertex sum under a chain flip.

                The vertex sum ignores the through legs #

                The core colouring constraint reaches only the core flags, and a through edge's legs are not among them. Flipping the state's odd colour to its partner at two such legs therefore leaves the vertex sum alone: the even constraint does not see an odd leg at all, and the odd constraint does not see a through one.

                theorem RS.EdgeSubset.vertexSum_stateOddFlip_through {α : Type} {W : Fragment α} {F : EdgeSubset W} {k ℓ : ℕ} (h : MixedFunctional k ℓ) (st : GenBoundaryState k ℓ α) (hbnd : genBoundarySubsetMatches W F.flags st) {κ : F.RelTransitionSystem} (o : κ.Orientation) (i₁ i₂ : α) (h₁ : W.boundaryFlag i₁ ∈ F.throughFlags) (h₂ : W.boundaryFlag i₂ ∈ F.throughFlags) :
                F.vertexSum h (stateOddFlip st i₁ i₂) ⋯ o = F.vertexSum h st hbnd o

                Flipping the state at two through legs leaves the vertex sum unchanged.

                The tensor under a chain flip #

                RS21: inverting a directed trail negates t′_h. The two ledgers meet — the dual basis contributes dualSign at each chain end, the colouring sum contributes the flipped state's own sign there — and each pair is 1 where the trail leaves and -1 where it enters. Exactly one end of a chain is its tail, so the product is -1.

                theorem RS.EdgeSubset.dualSign_mul_self {ℓ : ℕ} (c : Fin (2 * ℓ)) :
                dualSign ℓ c * ↑(oddPartnerSign ℓ c) = 1

                The dual sign against the state's own sign.

                theorem RS.EdgeSubset.dualSign_mul_partner {ℓ : ℕ} (c : Fin (2 * ℓ)) :
                dualSign ℓ c * ↑(oddPartnerSign ℓ (oddPartner ℓ c)) = -1

                The dual sign against the partner colour's sign.

                theorem RS.EdgeSubset.tPrime_portFlip {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ : F.RelTransitionSystem} (o : κ.Orientation) {S : Finset W.Flag} {p₁ p₂ : W.Flag} {i₁ i₂ : α} (hp : PortedFlipSet κ S p₁ p₂ i₁ i₂) (hb₁ : W.boundaryFlag i₁ ∈ F.boundaryFlags) (hchord : F.chordInv κ i₁ = i₂) (x : GenBoundaryState k ℓ α) {c₁ c₂ : Fin (2 * ℓ)} (hc₁ : x i₁ = Sum.inr c₁) (hc₂ : x i₂ = Sum.inr c₂) (hbnd : genBoundarySubsetMatches W F.flags (untwist F κ o x)) (hbnd' : genBoundarySubsetMatches W F.flags (untwist F κ (o.portFlip hp) x)) (hag : F.ThroughAgree (untwist F κ o x) hbnd) (hag' : F.ThroughAgree (untwist F κ (o.portFlip hp) x) hbnd') :
                F.tPrime h κ (o.portFlip hp) x = -F.tPrime h κ o x

                The tensor changes sign under a chain flip — RS21's t′_h(F,H,ω,κ) = -t′_h(F,H,ω′,κ′). The dual basis contributes the chain ends' own signs and the colouring sum contributes the flipped state's; each pair is 1 at the end the trail leaves and -1 at the end it enters, and a trail leaves exactly one of its two ends.

                Inverting an edge joining two labelled ends #

                RS21's (12) inverts a directed trail. When the trail is a single edge with both ends labelled there is no transition to invert, so the whole effect falls on the dual basis: the two legs exchange f and g. The colouring moves too — the edge's colour becomes its partner — but that colour occurs at no vertex, so the vertex sum is unchanged and the two weights differ by exactly one sign. This is RS21's count of one arc and no pairings.

                theorem RS.EdgeSubset.tPrimeD_reverseArc {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (M : DirMatching (UsedLab F)) (a : UsedLab F) (x : GenBoundaryState k ℓ α) (hthr₁ : W.boundaryFlag ↑a ∈ F.throughFlags) (hthr₂ : W.boundaryFlag ↑(M.edge a) ∈ F.throughFlags) (hta : M.tail a = true) {c : Fin (2 * ℓ)} (hca : x ↑a = Sum.inr c) (hca' : x ↑(M.edge a) = Sum.inr (oddPartner ℓ c)) (hbnd : genBoundarySubsetMatches W F.flags (untwistD F M.tail x)) (hbnd' : genBoundarySubsetMatches W F.flags (untwistD F (M.reverseArc a).tail x)) (hag : F.ThroughAgree (untwistD F M.tail x) hbnd) (hag' : F.ThroughAgree (untwistD F (M.reverseArc a).tail x) hbnd') :
                F.tPrimeD h κ o (M.reverseArc a).tail x = -F.tPrimeD h κ o M.tail x

                Inverting an edge joining two labelled ends negates the tensor.

                theorem RS.EdgeSubset.tFullD_reverseArc {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (M : DirMatching (UsedLab F)) (a : UsedLab F) (x : GenBoundaryState k ℓ α) (hthr₁ : W.boundaryFlag ↑a ∈ F.throughFlags) (hthr₂ : W.boundaryFlag ↑(M.edge a) ∈ F.throughFlags) (hta : M.tail a = true) {c : Fin (2 * ℓ)} (hca : x ↑a = Sum.inr c) (hca' : x ↑(M.edge a) = Sum.inr (oddPartner ℓ c)) (hbnd : genBoundarySubsetMatches W F.flags (untwistD F M.tail x)) (hbnd' : genBoundarySubsetMatches W F.flags (untwistD F (M.reverseArc a).tail x)) (hag : F.ThroughAgree (untwistD F M.tail x) hbnd) (hag' : F.ThroughAgree (untwistD F (M.reverseArc a).tail x) hbnd') :
                F.tFullD h κ o (M.reverseArc a) x = F.tFullD h κ o M x

                RS21's (12) at the normalised tensor: inverting an edge joining two labelled ends leaves t_h alone, because the matching's sign and the tensor both change sign.

                theorem RS.EdgeSubset.tFull_portFlip {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ : F.RelTransitionSystem} (o : κ.Orientation) {S : Finset W.Flag} {p₁ p₂ : W.Flag} {i₁ i₂ : α} (hp : PortedFlipSet κ S p₁ p₂ i₁ i₂) (hb₁ : W.boundaryFlag i₁ ∈ F.boundaryFlags) (hchord : F.chordInv κ i₁ = i₂) (x : GenBoundaryState k ℓ α) {c₁ c₂ : Fin (2 * ℓ)} (hc₁ : x i₁ = Sum.inr c₁) (hc₂ : x i₂ = Sum.inr c₂) (hbnd : genBoundarySubsetMatches W F.flags (untwist F κ o x)) (hbnd' : genBoundarySubsetMatches W F.flags (untwist F κ (o.portFlip hp) x)) (hag : F.ThroughAgree (untwist F κ o x) hbnd) (hag' : F.ThroughAgree (untwist F κ (o.portFlip hp) x) hbnd') :
                F.tFull h κ (o.portFlip hp) x = F.tFull h κ o x

                RS21's (12) at the normalised tensor, for a chain: inverting a directed trail through the interior leaves t_h alone, because the matching's sign and the tensor both change sign. The orientation moves with the trail, which is what distinguishes this from the case of an edge joining two labelled ends.

                theorem RS.EdgeSubset.tFull_portFlip_all {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) {κ : F.RelTransitionSystem} (o : κ.Orientation) {S : Finset W.Flag} {p₁ p₂ : W.Flag} {i₁ i₂ : α} (hp : PortedFlipSet κ S p₁ p₂ i₁ i₂) (hb₁ : W.boundaryFlag i₁ ∈ F.boundaryFlags) (hchord : F.chordInv κ i₁ = i₂) (hnt₁ : ¬IsThroughLabel F i₁) (hnt₂ : ¬IsThroughLabel F i₂) (x : GenBoundaryState k ℓ α) :
                F.tFull h κ (o.portFlip hp) x = F.tFull h κ o x

                RS21's (12) for a chain, at every state. Off the tensor's support both sides vanish, so the invariance needs no hypothesis on the state.

                The tensor does not see those edges' directions #

                Since inverting such an edge leaves t_h alone, and any two direction assignments on them differ by a set of such inversions, the normalised tensor is the same for all of them. This is RS21's "we may assume that ω₁, κ₁, ω₂, κ₂ are chosen so that the union is Eulerian", for the half of the choice the chain orientation does not already provide.

                theorem RS.EdgeSubset.tFullD_congr_through {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (x : GenBoundaryState k ℓ α) (hx : genBoundarySubsetMatches W F.flags x) (n : ℕ) (M M' : DirMatching (UsedLab F)) :
                M'.edge = M.edge → (∀ (N : DirMatching (UsedLab F)), N.edge = M.edge → F.ThroughAgree (untwistD F N.tail x) ⋯) → (∀ (a : UsedLab F), M'.tail a ≠ M.tail a → W.boundaryFlag ↑a ∈ F.throughFlags) → (∀ (a : UsedLab F), W.boundaryFlag ↑a ∈ F.throughFlags → W.boundaryFlag ↑(M.edge a) ∈ F.throughFlags) → (∀ (a : UsedLab F), W.boundaryFlag ↑a ∈ F.throughFlags → ∃ (c : Fin (2 * ℓ)), x ↑a = Sum.inr c ∧ x ↑(M.edge a) = Sum.inr (oddPartner ℓ c)) → (M.flipSet M').card = 2 * n → F.tFullD h κ o M' x = F.tFullD h κ o M x

                The normalised tensor is independent of the directions given to the edges joining two labelled ends.

                A through edge's two labels carry partner colours #

                The colouring the tensor sums over gives a through edge one colour, so in the twisted basis its two labels carry partner colours — which is what RS21's (12) reads at such an edge. It is not an extra hypothesis: it follows from the agreement the colouring forces.

                At a through label the chord is the edge's other end.

                theorem RS.EdgeSubset.partner_of_throughAgree {α : Type} {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (κ : F.RelTransitionSystem) (M : DirMatching (UsedLab F)) (hM : ∀ (a : UsedLab F), ↑(M.edge a) = F.chordInv κ ↑a) (x : GenBoundaryState k ℓ α) (hx : genBoundarySubsetMatches W F.flags x) (hag : F.ThroughAgree (untwistD F M.tail x) ⋯) (a : UsedLab F) (hthr : W.boundaryFlag ↑a ∈ F.throughFlags) :
                ∃ (c : Fin (2 * ℓ)), x ↑a = Sum.inr c ∧ x ↑(M.edge a) = Sum.inr (oddPartner ℓ c)

                A through edge's two labels carry partner colours.

                theorem RS.EdgeSubset.throughAgree_of_partner {α : Type} {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (κ : F.RelTransitionSystem) (M : DirMatching (UsedLab F)) (hM : ∀ (a : UsedLab F), ↑(M.edge a) = F.chordInv κ ↑a) (x : GenBoundaryState k ℓ α) (hx : genBoundarySubsetMatches W F.flags x) (hpart : ∀ (i : α), W.boundaryFlag i ∈ F.boundaryFlags → IsThroughLabel F i → ∀ (c : Fin (2 * ℓ)), x i = Sum.inr c → x (F.chordInv κ i) = Sum.inr (oddPartner ℓ c)) :
                F.ThroughAgree (untwistD F M.tail x) ⋯

                Agreement is a condition on the state alone. At a through edge it says the two labels' colours are partners, and reading that does not need the arc directions: reversing the edge replaces both ends' colours by their partners at once.

                theorem RS.EdgeSubset.throughAgree_congr_matching {α : Type} {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (κ : F.RelTransitionSystem) (M M' : DirMatching (UsedLab F)) (hM : ∀ (a : UsedLab F), ↑(M.edge a) = F.chordInv κ ↑a) (hM' : ∀ (a : UsedLab F), ↑(M'.edge a) = F.chordInv κ ↑a) (x : GenBoundaryState k ℓ α) (hx : genBoundarySubsetMatches W F.flags x) (hag : F.ThroughAgree (untwistD F M.tail x) ⋯) :
                F.ThroughAgree (untwistD F M'.tail x) ⋯

                The agreement does not read the arc directions.

                RS21's step 1, the chain half #

                The directions at the chain labels are the chain orientation's own, and a chain flip reverses exactly one of their arcs at no cost to the tensor. So the orientation can be chosen to give those labels any directions the pairing allows — which is half of "we may assume that ω₁, κ₁, ω₂, κ₂ are chosen so that the union is Eulerian".

                theorem RS.EdgeSubset.exists_orient_chainAgree {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (n : ℕ) (o : κ.Orientation) (P : DirMatching (UsedLab F)) :
                P.edge = (cutMatching F κ o).edge → {a ∈ (cutMatching F κ o).flipSet P | ¬IsThroughLabel F ↑a}.card = 2 * n → ∃ (o' : κ.Orientation), (∀ (a : UsedLab F), ¬IsThroughLabel F ↑a → P.tail a = (cutMatching F κ o').tail a) ∧ ∀ (x : GenBoundaryState k ℓ α), F.tFull h κ o' x = F.tFull h κ o x

                The chain labels' directions can be chosen freely.

                theorem RS.EdgeSubset.exists_orient_tFullD {α : Type} [LinearOrder α] [Fintype α] {W : Fragment α} (F : EdgeSubset W) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ : F.RelTransitionSystem) (o : κ.Orientation) (P : DirMatching (UsedLab F)) (hP : ∀ (a : UsedLab F), ↑(P.edge a) = F.chordInv κ ↑a) :
                ∃ (o' : κ.Orientation), (∀ (a : UsedLab F), ¬IsThroughLabel F ↑a → P.tail a = (cutMatching F κ o').tail a) ∧ ∀ (x : GenBoundaryState k ℓ α), F.tFullD h κ o' P x = F.tFull h κ o x

                RS21's step 1. The arc directions can be given any values the pairing allows, at no cost to the tensor: the chain labels' by choosing the orientation, the through labels' outright.

                The Eulerian position #

                RS21's step 1 asks for directions making M(ω₁,κ₁) ∪ M(ω₂,κ₂) Eulerian, and Lemma 11's repair supplies them. Since the tensor does not read the directions beyond their pairing, they can be imposed on both sides at once.

                def RS.EdgeSubset.usedLabInterfaceEquiv {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) (hused : ∀ (i : Fin t), W₁.boundaryFlag i ∈ F₁.boundaryFlags ↔ W₂.boundaryFlag i ∈ F₂.boundaryFlags) :
                UsedLab F₁ ≃ UsedLab F₂

                The two subsets' used labels, identified by the interface.

                Equations
                Instances For
                  theorem RS.EdgeSubset.exists_eulerianPosition {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) (κ₁ : F₁.RelTransitionSystem) (o₁ : κ₁.Orientation) (κ₂ : F₂.RelTransitionSystem) (o₂ : κ₂.Orientation) (hused : ∀ (i : Fin t), W₁.boundaryFlag i ∈ F₁.boundaryFlags ↔ W₂.boundaryFlag i ∈ F₂.boundaryFlags) :
                  ∃ (M₁ : DirMatching (UsedLab F₁)) (M₂ : DirMatching (UsedLab F₂)), (∀ (a : UsedLab F₁), ↑(M₁.edge a) = F₁.chordInv κ₁ ↑a) ∧ (∀ (b : UsedLab F₂), ↑(M₂.edge b) = F₂.chordInv κ₂ ↑b) ∧ ∀ (a : UsedLab F₁), M₂.tail ((F₁.usedLabInterfaceEquiv F₂ hused) a) = !M₁.tail a

                  The two subsets' arc directions can be put in Eulerian position, keeping the pairings.

                  theorem RS.EdgeSubset.exists_sum_sum_superForm_tFull {t : ℕ} {W₁ W₂ : Fragment (Fin t)} (F₁ : EdgeSubset W₁) (F₂ : EdgeSubset W₂) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (κ₁ : F₁.RelTransitionSystem) (o₁ : κ₁.Orientation) (κ₂ : F₂.RelTransitionSystem) (o₂ : κ₂.Orientation) (m : ℕ) (hcard₁ : Fintype.card (UsedLab F₁) = 2 * m) (hcard₂ : Fintype.card (UsedLab F₂) = 2 * m) (hused : ∀ (i : Fin t), W₁.boundaryFlag i ∈ F₁.boundaryFlags ↔ W₂.boundaryFlag i ∈ F₂.boundaryFlags) :
                  ∃ (o₁' : κ₁.Orientation) (o₂' : κ₂.Orientation) (M₁ : DirMatching (UsedLab F₁)) (M₂ : DirMatching (UsedLab F₂)), (∀ (a : UsedLab F₁), ↑(M₁.edge a) = F₁.chordInv κ₁ ↑a) ∧ (∀ (b : UsedLab F₂), ↑(M₂.edge b) = F₂.chordInv κ₂ ↑b) ∧ (∀ (a : UsedLab F₁), M₂.tail ((F₁.usedLabInterfaceEquiv F₂ hused) a) = !M₁.tail a) ∧ (∀ (a : UsedLab F₁), ¬IsThroughLabel F₁ ↑a → M₁.tail a = (cutMatching F₁ κ₁ o₁').tail a) ∧ (∀ (b : UsedLab F₂), ¬IsThroughLabel F₂ ↑b → M₂.tail b = (cutMatching F₂ κ₂ o₂').tail b) ∧ (∀ (a : UsedLab F₁), ¬IsThroughLabel F₁ ↑a → ¬IsThroughLabel F₂ ↑((F₁.usedLabInterfaceEquiv F₂ hused) a) → (cutMatching F₂ κ₂ o₂').tail ((F₁.usedLabInterfaceEquiv F₂ hused) a) = !(cutMatching F₁ κ₁ o₁').tail a) ∧ ∑ x : GenBoundaryState k ℓ (Fin t), ∑ y : GenBoundaryState k ℓ (Fin t), superForm t x y * F₁.tFull h κ₁ o₁ x * F₂.tFull h κ₂ o₂ y = ↑↑((DirMatching.stdMatching ⋯).sgnRel M₁) * (-1) ^ κ₁.openCircuitCount * (↑↑((DirMatching.stdMatching ⋯).sgnRel M₂) * (-1) ^ κ₂.openCircuitCount) * ∑ st : GenBoundaryState k ℓ (Fin t), F₁.pairAgreeValue F₂ h o₁' o₂' st

                  RS21's (13), with the directions discharged. Step 1 supplies the Eulerian position and the tensor does not see it, so the pairing of the two fragments' tensors is the two colouring sums against the sign bookkeeping, with no hypothesis on the directions.

                  The fragment's tensor #

                  Summing the normalised tensors over the Eulerian subsets gives the fragment's own tensor, at the transition data each subset's canonical data provide. Any choice of data serves, by the invariance under reversing a trail.

                  noncomputable def RS.tensorSum {α : Type} [LinearOrder α] [Fintype α] (V : Fragment α) {k ℓ : ℕ} (h : MixedFunctional k ℓ) (x : GenBoundaryState k ℓ α) :

                  The fragment's tensor: Σ_H t_h(F,H,ω_H,κ_H).

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For