Documentation

LeanPool.RegtsSevenster.RS.Novel.Skein.SuperGram

The super form on boundary states, and the rank it bounds #

A boundary state at arity t is a coordinate of the t-fold tensor power of V_k ⊕ V_{2ℓ}, so a vector in that power is a function on boundary states. The ambient bilinear form is the t-fold product of the super form on one leg: the identity on the even colours and the symplectic form on the odd ones, zero across the two. That one leg's form is the through-edge state factor the mixed partition function already uses.

Writing the connection pairing as this form evaluated at vectors attached to the two fragments bounds the edge-rank by (k + 2ℓ)^t, because that is how many boundary states there are.

noncomputable def RS.superForm {k ℓ : ℕ} (t : ℕ) (x y : GenBoundaryState k ℓ (Fin t)) :

The super form on boundary states at arity t: the product over the legs of the one-leg form of RS21 (11) — the identity on the even colours and the symplectic form on the odd ones, zero across the two.

Equations
Instances For
    theorem RS.edgeRankBounded_of_superGram {k ℓ : ℕ} {f : ClosedFragment → ℂ} (T : (t : ℕ) → Fragment (Fin t) → GenBoundaryState k ℓ (Fin t) → ℂ) (hgram : ∀ (t : ℕ) (F G : Fragment (Fin t)), connectionPairing f t F G = ∑ x : GenBoundaryState k ℓ (Fin t), ∑ y : GenBoundaryState k ℓ (Fin t), superForm t x y * T t F x * T t G y) :
    EdgeRankBounded f (k + 2 * ℓ)

    A super-Gram factorization bounds the edge-rank by k + 2ℓ.

    The fragment tensor's normalisation #

    The super form pairs an odd leg's two colours antisymmetrically, so across the legs a matched pair of fragments picks up (-1) once for each of the half of the used legs where the first fragment's arc enters. The fragment tensor carries a fourth root of unity per two used legs, and the two fragments' roots multiply to exactly that sign. Since a leg is used exactly when its colour is odd, the factor depends on the boundary state alone.

    noncomputable def RS.oddCount {k ℓ t : ℕ} (x : GenBoundaryState k ℓ (Fin t)) :

    The number of legs a boundary state colours oddly.

    Equations
    Instances For
      noncomputable def RS.stateTwist {k ℓ t : ℕ} (x : GenBoundaryState k ℓ (Fin t)) :

      The fragment tensor's normalising root: a fourth root of unity, one quarter turn for every two odd legs.

      Equations
      Instances For
        theorem RS.stateTwist_mul_stateTwist {k ℓ t : ℕ} {x y : GenBoundaryState k ℓ (Fin t)} (hxy : oddCount x = oddCount y) :

        The two fragments' roots multiply to the form's sign. On a matched pair of states the product is (-1) to half the number of odd legs — exactly the sign the antisymmetric legs contribute.

        theorem RS.stateTwist_mul_stateTwist_mul_half {k ℓ t : ℕ} {x y : GenBoundaryState k ℓ (Fin t)} (hxy : oddCount x = oddCount y) {m : ℕ} (hm : oddCount x = 2 * m) :
        stateTwist x * stateTwist y * (-1) ^ m = 1

        The roots cancel the legs' sign — RS21's "these contributions cancel with (-1)^{|S(H₁)|/4} (-1)^{|S(H₂)|/4}". At half the used legs the first fragment's arc enters and the form is ⟨f_c, g_c⟩ = -1; at the other half it leaves and the form is ⟨g_c, f_c⟩ = 1. So the legs contribute (-1) to half the number of used legs, and the two fragments' fourth roots multiply to the same thing.

        The form vanishes across a parity mismatch #

        The one-leg form is zero between an even colour and an odd one, so two states differing in parity at any leg pair to zero. This is what makes two fragments' tensors orthogonal when their subsets use different label sets.

        theorem RS.superForm_eq_zero_of_left_right {k ℓ t : ℕ} (x y : GenBoundaryState k ℓ (Fin t)) (i : Fin t) {a : Fin k} {c : Fin (2 * ℓ)} (hx : x i = Sum.inl a) (hy : y i = Sum.inr c) :
        superForm t x y = 0

        An even leg against an odd one kills the form.

        theorem RS.superForm_eq_zero_of_right_left {k ℓ t : ℕ} (x y : GenBoundaryState k ℓ (Fin t)) (i : Fin t) {c : Fin (2 * ℓ)} {a : Fin k} (hx : x i = Sum.inr c) (hy : y i = Sum.inl a) :
        superForm t x y = 0

        And an odd leg against an even one.

        theorem RS.exists_left_of_not_right {k ℓ : ℕ} {v : Fin k ⊕ Fin (2 * ℓ)} (h : ¬∃ (c : Fin (2 * ℓ)), v = Sum.inr c) :
        ∃ (a : Fin k), v = Sum.inl a

        A colour that is not odd is even.

        The form is diagonal in the partner pairing #

        RS21 pairs two fragments' tensors coordinate by coordinate and observes that the pairing vanishes unless the two coordinates agree — the even colours outright, and the odd ones because the two orientations are opposite at a used leg, so the same colour appears against its dual basis vector.

        Written in one basis the second coordinate is not equal to the first but dual to it: the same colour on an even leg, the partner colour on an odd one. So the form has exactly one nonzero coordinate for each state, and the double sum over coordinates collapses to a single one.

        noncomputable def RS.dualLeg {k ℓ : ℕ} :
        Fin k ⊕ Fin (2 * ℓ) → Fin k ⊕ Fin (2 * ℓ)

        The dual of one leg's colour: itself on an even colour, the partner on an odd one.

        Equations
        Instances For
          noncomputable def RS.dualState {k ℓ : ℕ} {α : Type} (x : GenBoundaryState k ℓ α) :

          The dual state: the dual colour at every leg.

          Equations
          Instances For
            theorem RS.superLeg_eq_zero_of_ne_dualLeg {k ℓ : ℕ} (u v : Fin k ⊕ Fin (2 * ℓ)) (h : v ≠ dualLeg u) :
            superLeg u v = 0

            One leg's form vanishes off the dual colour.

            theorem RS.superForm_eq_zero_of_ne_dualState {k ℓ t : ℕ} (x y : GenBoundaryState k ℓ (Fin t)) (h : y ≠ dualState x) :
            superForm t x y = 0

            The form vanishes off the dual state.

            noncomputable def RS.legSelf {k ℓ : ℕ} :
            Fin k ⊕ Fin (2 * ℓ) → ℂ

            One leg's form against its own dual: 1 on an even colour, and on an odd one the negated dual sign — RS21's ⟨f_c, g_c⟩.

            Equations
            Instances For
              theorem RS.superLeg_dualLeg {k ℓ : ℕ} (u : Fin k ⊕ Fin (2 * ℓ)) :

              The one-leg form at the dual colour.

              theorem RS.superForm_dualState {k ℓ t : ℕ} (x : GenBoundaryState k ℓ (Fin t)) :
              superForm t x (dualState x) = ∏ i : Fin t, legSelf (x i)

              The form at the dual state is the product of the legs' own values.

              theorem RS.sum_sum_superForm {k ℓ t : ℕ} (T₁ T₂ : GenBoundaryState k ℓ (Fin t) → ℂ) :
              ∑ x : GenBoundaryState k ℓ (Fin t), ∑ y : GenBoundaryState k ℓ (Fin t), superForm t x y * T₁ x * T₂ y = ∑ x : GenBoundaryState k ℓ (Fin t), (∏ i : Fin t, legSelf (x i)) * T₁ x * T₂ (dualState x)

              The Gram double sum collapses. Only the dual coordinate contributes, so a pairing written against the form is a single sum over boundary states.

              The leg bracket #

              At a used leg the two fragments each contribute a dual-basis weight and the form contributes its entry. Their product is RS21's leg value: -1 where the first fragment's arc leaves the leg and 1 where it enters — provided the two arcs point oppositely, which is what the Eulerian condition on the union of the two matchings says.

              theorem RS.legBracket_odd {k ℓ : ℕ} (u : Fin (2 * ℓ)) (t₁ : Bool) :
              ((if t₁ = true then dualSign ℓ u else 1) * if (!t₁) = true then dualSign ℓ (oddPartner ℓ u) else 1) * superLeg (Sum.inr u) (Sum.inr (oddPartner ℓ u)) = if t₁ = true then -1 else 1

              The leg bracket on an odd leg — RS21's ⟨f_c, g_c⟩ = -1 and ⟨g_c, f_c⟩ = 1, read in the coordinates the tensor uses.

              theorem RS.legBracket_even {k ℓ : ℕ} (a : Fin k) :

              The leg bracket on an even leg is trivial.

              The legs, multiplied out #

              Each fragment's dual-basis weight is a product over the legs, so the whole leg contribution is a product of brackets. With the two matchings' arcs opposite at every leg, each bracket is -1 exactly where the first fragment's arc leaves, so the product is (-1) to the number of such legs — half the used ones, which is RS21's count.

              noncomputable def RS.legWeight {k ℓ : ℕ} (b : Bool) (v : Fin k ⊕ Fin (2 * ℓ)) :

              One leg's dual-basis weight, as it occurs in dualWeight.

              Equations
              Instances For
                theorem RS.prod_legWeight_congr {k ℓ t : ℕ} (b b' : Fin t → Bool) (x : GenBoundaryState k ℓ (Fin t)) (h : ∀ (i : Fin t), (∃ (c : Fin (2 * ℓ)), x i = Sum.inr c) → b i = b' i) :
                ∏ i : Fin t, legWeight (b i) (x i) = ∏ i : Fin t, legWeight (b' i) (x i)

                The leg weights only see the used legs. At an even colour the weight is one whichever way the arc points, so two direction assignments agreeing on the odd legs give the same product. This is what lets the two fragments' directions be compared only where both subsets are used.

                theorem RS.legWeight_mul {k ℓ : ℕ} (b : Bool) (v : Fin k ⊕ Fin (2 * ℓ)) :
                legWeight b v * legWeight (!b) (dualLeg v) * superLeg v (dualLeg v) = if (∃ (c : Fin (2 * ℓ)), v = Sum.inr c) ∧ b = true then -1 else 1

                The bracket at one leg.

                Undoing the dual basis is a bijection of states #

                Summing a tensor's coordinates and summing the partition function's states are the same sum: the dual basis relabels the colour at the legs whose arc leaves, and that relabelling is an involution.

                The dual colour is an involution.

                noncomputable def RS.untwistState {k ℓ t : ℕ} (b : Fin t → Bool) (x : GenBoundaryState k ℓ (Fin t)) :

                Undoing the dual basis at the legs whose arc leaves.

                Equations
                Instances For

                  Untwisting a state at a fixed sign pattern is an involution.

                  theorem RS.sum_untwistState {k ℓ t : ℕ} (b : Fin t → Bool) (V : GenBoundaryState k ℓ (Fin t) → ℂ) :
                  ∑ x : GenBoundaryState k ℓ (Fin t), V (untwistState b x) = ∑ st : GenBoundaryState k ℓ (Fin t), V st

                  The two sums agree.

                  theorem RS.dualState_isInr {k ℓ t : ℕ} (x : GenBoundaryState k ℓ (Fin t)) (i : Fin t) :
                  (∃ (c : Fin (2 * ℓ)), dualState x i = Sum.inr c) ↔ ∃ (c : Fin (2 * ℓ)), x i = Sum.inr c

                  The dual state colours the same legs oddly, pointwise.

                  theorem RS.untwistState_dualState' {k ℓ t : ℕ} (b₁ b₂ : Fin t → Bool) (x : GenBoundaryState k ℓ (Fin t)) (hb : ∀ (i : Fin t), (∃ (c : Fin (2 * ℓ)), x i = Sum.inr c) → b₂ i = !b₁ i) :

                  RS21's χ = χ′, needing the directions opposite only where both subsets are used. At an even leg the dual colour is the colour, so the two sides agree there whatever the directions say.

                  Contracting one leg #

                  Summing a fragment tensor's coordinate at a used leg against the form is the same as summing the partition function's own colour there. The two differ by the partner relabelling the dual basis performs, which is a bijection of the odd colours, and by RS21's leg value.

                  theorem RS.prod_legBracket {k ℓ t : ℕ} (x : GenBoundaryState k ℓ (Fin t)) (b : Fin t → Bool) :
                  ((∏ i : Fin t, legWeight (b i) (x i)) * ∏ i : Fin t, legWeight (!b i) (dualLeg (x i))) * superForm t x (dualState x) = (-1) ^ {i : Fin t | (∃ (c : Fin (2 * ℓ)), x i = Sum.inr c) ∧ b i = true}.card

                  The legs' product: (-1) to the number of legs at which the first fragment's arc leaves.

                  theorem RS.oddCount_dualState {k ℓ t : ℕ} (x : GenBoundaryState k ℓ (Fin t)) :

                  The dual state colours the same legs oddly.

                  theorem RS.legs_cancel_twists {k ℓ t : ℕ} (x : GenBoundaryState k ℓ (Fin t)) (b : Fin t → Bool) (hcount : oddCount x = 2 * {i : Fin t | (∃ (c : Fin (2 * ℓ)), x i = Sum.inr c) ∧ b i = true}.card) :
                  stateTwist x * stateTwist (dualState x) * (((∏ i : Fin t, legWeight (b i) (x i)) * ∏ i : Fin t, legWeight (!b i) (dualLeg (x i))) * superForm t x (dualState x)) = 1

                  RS21's cancellation, assembled: the two fragments' fourth roots and the legs' product cancel, provided the first fragment's arc leaves at half the used legs — which is what the Eulerian condition on the union gives.

                  The legs contracted, all at once #

                  Putting the two together: the bracket product is (-1) to the number of legs the first fragment's arc leaves, and undoing the dual basis is a bijection of states. So the Gram sum in the tensor's coordinates is the partition function's sum over states, times RS21's leg sign — provided the tensors are supported where the used legs are the same, which is what (16) already says.

                  theorem RS.sum_legBracket_with_twists {k ℓ t : ℕ} (b : Fin t → Bool) (V : GenBoundaryState k ℓ (Fin t) → ℂ) (m : ℕ) (hodd : ∀ (x : GenBoundaryState k ℓ (Fin t)), V (untwistState b x) ≠ 0 → {i : Fin t | (∃ (c : Fin (2 * ℓ)), x i = Sum.inr c) ∧ b i = true}.card = m) (hcnt : ∀ (x : GenBoundaryState k ℓ (Fin t)), V (untwistState b x) ≠ 0 → oddCount x = 2 * m) :
                  ∑ x : GenBoundaryState k ℓ (Fin t), stateTwist x * stateTwist (dualState x) * (((∏ i : Fin t, legWeight (b i) (x i)) * ∏ i : Fin t, legWeight (!b i) (dualLeg (x i))) * superForm t x (dualState x)) * V (untwistState b x) = ∑ st : GenBoundaryState k ℓ (Fin t), V st

                  RS21's step 5, complete. With the two fragments' fourth roots included, the Gram sum in the tensor's coordinates is the partition function's own sum over states, with no residual sign: the legs' (-1) per entering arc is exactly cancelled by the roots.

                  theorem RS.sum_legBracket_with_twists' {k ℓ t : ℕ} (b₁ b₂ : Fin t → Bool) (V : GenBoundaryState k ℓ (Fin t) → ℂ) (m : ℕ) (hodd : ∀ (x : GenBoundaryState k ℓ (Fin t)), V (untwistState b₁ x) ≠ 0 → {i : Fin t | (∃ (c : Fin (2 * ℓ)), x i = Sum.inr c) ∧ b₁ i = true}.card = m) (hcnt : ∀ (x : GenBoundaryState k ℓ (Fin t)), V (untwistState b₁ x) ≠ 0 → oddCount x = 2 * m) (hb : ∀ (x : GenBoundaryState k ℓ (Fin t)), V (untwistState b₁ x) ≠ 0 → ∀ (i : Fin t), (∃ (c : Fin (2 * ℓ)), x i = Sum.inr c) → b₂ i = !b₁ i) :
                  ∑ x : GenBoundaryState k ℓ (Fin t), stateTwist x * stateTwist (dualState x) * (((∏ i : Fin t, legWeight (b₁ i) (x i)) * ∏ i : Fin t, legWeight (b₂ i) (dualLeg (x i))) * superForm t x (dualState x)) * V (untwistState b₁ x) = ∑ st : GenBoundaryState k ℓ (Fin t), V st

                  RS21's step 5, with the second fragment's own directions. The two fragments each carry their own arc directions; they need only be opposite at the legs both subsets use, since an even leg's weight is one either way.