Documentation

TauCeti.KnotTheory.Grid.Differential.Square.Recut.Pairing

The recut pairing on two-step grid rectangle decompositions #

A nondiagonal term in the square of the unblocked grid differential ∂⁻ is a pair of composable empty rectangles whose two pairs of side columns are disjoint or share exactly one column. In the second case the two rectangles meet at a corner, their union is an L-shaped hexagon, and cutting that hexagon the other way gives a second such pair through a different intermediate grid state. The four orientations of the common column are constructed in Recut/Initial.lean, Recut/Terminal.lean and Recut/Mixed.lean, each as the unique decomposition carrying the side data computed there. This file assembles those four constructions into a single involution, the pairing that cancels the one-common-side terms of ∂⁻ ∘ ∂⁻ in characteristic two.

GridRectangleDecomposition.IsRecut collects the four side-data alternatives into one relation. A decomposition has at most one orientation of its common column, so exactly one alternative can hold and the relation has a unique solution. Recutting twice returns the original decomposition: a common initial or terminal column recuts to a mixed common column and conversely, and in each of the eight resulting configurations the original decomposition satisfies precisely the side data that describes the recut of the recut. On the decompositions by two empty rectangles sharing exactly one side column -- the only ones for which a recut is constructed -- the relation is therefore symmetric, and uniqueness turns it into an involution GridRectangleDecomposition.recut of that set. It has no fixed point, since the intermediate state changes, and it preserves the covered-square domain, hence every weight computed from the squares a two-step term covers: the monomial V^{O(r₁)} · V^{O(r₂)} that the square of the differential attaches to it, and which markings the domain carries.

The pairing is stated for empty rectangles, with no condition on the markings they cover: any condition on the markings in the covered domain, such as the avoidance of X-markings that ∂⁻ ∘ ∂⁻ requires, is transported separately along GridRectangleDecomposition.IsRepartition.

The geometric input is the cyclic order forced by emptiness of both rectangles: for a common initial or terminal column the corner row of the common side lies strictly between the other two corner rows, and for a mixed common column the terminal side of the first rectangle lies strictly between the other two side columns. That one order fact decides which of the two alternatives of the recut's own side data holds.

Main definitions #

Main results #

References #

The recut of an L-shaped juxtaposition follows Ozsváth--Stipsicz--Szabó, Grid Homology for Knots and Links, Chapter 4.6.

The side data of the recut of a decomposition whose two rectangles share their initial side column.

Instances For

    The side data of the recut of a decomposition whose two rectangles share their terminal side column.

    Instances For

      The side data of the recut of a decomposition whose common column is the initial side of its first rectangle and the terminal side of its second.

      Instances For

        The side data of the recut of a decomposition whose common column is the terminal side of its first rectangle and the initial side of its second.

        Instances For

          E is the recut of the two-step decomposition D: it repartitions the same domain into two empty rectangles, passes through a different intermediate state, and carries the side data computed for the orientation of the common side column of D.

          Instances For

            The common initial side in the left = left recut orientation.

            The outer sides retained by a left = left recut.

            The common initial side of D is not a common side column of its left = left recut.

            The common terminal side in the right = right recut orientation.

            The outer sides retained by a right = right recut.

            The common terminal side of D is not a common side column of its right = right recut.

            The mixed common side in the left = right recut orientation.

            The mixed common side in the right = left recut orientation.

            The outer sides retained by a right = left recut.

            A decomposition admitting a recut is nondiagonal: each of the four orientations of the recut data places the two rectangles on distinct side pairs.

            A decomposition admitting a recut has exactly one common side column: the side data of that recut records which of the four orientations the decomposition's own common column has.

            A recut of a decomposition whose rectangles share their initial side column has the left = left side data.

            A recut of a decomposition whose rectangles share their terminal side column has the right = right side data.

            Existence and uniqueness of the recut #

            A two-step decomposition by two empty rectangles sharing exactly one side column has exactly one recut.

            The recut of the recut #

            theorem TauCeti.GridRectangleDecomposition.IsRecut.symm {n : ℕ} {x z : GridState n} {D E : GridRectangleDecomposition x z} (h : D.IsRecut E) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :

            If E is a recut of a two-step decomposition D by two empty rectangles sharing exactly one side column, then D is a recut of E: in each of the four orientations of the common column of D, the recut carries precisely the side data that describes D as its recut.

            The recut as an involution #

            The two decompositions of a recut pair repartition the same domain.

            A recut passes through a different intermediate grid state.

            The first rectangle of a recut is empty.

            The second rectangle of a recut is empty.

            theorem TauCeti.GridRectangleDecomposition.IsRecut.eq_of_isRecut {n : ℕ} {x z : GridState n} {D E F : GridRectangleDecomposition x z} (hD : D.IsRecut F) (hE : E.IsRecut F) (hfD : D.first.IsEmpty) (hsD : D.second.IsEmpty) (hfE : E.first.IsEmpty) (hsE : E.second.IsEmpty) :
            D = E

            Two decompositions by empty rectangles with exactly one common side column that admit the same recut are equal.

            The recut of a two-step decomposition by two empty rectangles sharing exactly one side column.

            Instances For
              theorem TauCeti.GridRectangleDecomposition.isRecut_recut {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hone : D.HasOneCommonSide) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              D.IsRecut (D.recut hone hfirst hsecond)

              The recut of a decomposition is a recut of it.

              theorem TauCeti.GridRectangleDecomposition.isRecutOfLeftEqLeft_recut {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hcommon : D.first.left = D.second.left) (hone : D.HasOneCommonSide) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              D.IsRecutOfLeftEqLeft (D.recut hone hfirst hsecond)

              A decomposition whose rectangles share their initial side has a recut classified by the left = left side data of the original decomposition.

              theorem TauCeti.GridRectangleDecomposition.recut_sides_of_left_eq_left_of_mem_cIoo {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hcommon : D.first.left = D.second.left) (hcol : D.second.right ∈ Grid.cIoo D.first.left D.first.right) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              (D.recut ⋯ hfirst hsecond).first.left = D.first.left ∧ (D.recut ⋯ hfirst hsecond).first.right = D.second.right ∧ (D.recut ⋯ hfirst hsecond).second.left = D.second.right ∧ (D.recut ⋯ hfirst hsecond).second.right = D.first.right

              When two empty rectangles share their initial side and the second ends strictly inside the first's column interval, the recut runs from the common side to the second rectangle's terminal side, then on to the first rectangle's terminal side.

              theorem TauCeti.GridRectangleDecomposition.recut_sides_of_left_eq_left_of_first_right_mem_cIoo {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hcommon : D.first.left = D.second.left) (hcol : D.first.right ∈ Grid.cIoo D.first.left D.second.right) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              (D.recut ⋯ hfirst hsecond).first.left = D.first.right ∧ (D.recut ⋯ hfirst hsecond).first.right = D.second.right ∧ (D.recut ⋯ hfirst hsecond).second.left = D.first.left ∧ (D.recut ⋯ hfirst hsecond).second.right = D.first.right

              When two empty rectangles share their initial side and the first ends strictly inside the second's column interval, the recut runs between the two terminal sides, then from the common initial side to the first rectangle's terminal side.

              theorem TauCeti.GridRectangleDecomposition.recut_first_bottom_top_of_left_eq_left_of_mem_cIoo {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hcommon : D.first.left = D.second.left) (hcol : D.second.right ∈ Grid.cIoo D.first.left D.first.right) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              (D.recut ⋯ hfirst hsecond).first.bottom = D.first.bottom ∧ (D.recut ⋯ hfirst hsecond).first.top = D.second.top

              When two empty rectangles share their initial side and the second ends strictly inside the first's column interval, the first rectangle of the recut has the first rectangle's bottom row and the second rectangle's top row.

              When two empty rectangles share their initial side and the second ends strictly inside the first's column interval, the second rectangle of the recut has the first rectangle's rows.

              When two empty rectangles share their initial side and the first ends strictly inside the second's column interval, the first rectangle of the recut runs from the first rectangle's top row to the second rectangle's top row.

              When two empty rectangles share their initial side and the first ends strictly inside the second's column interval, the second rectangle of the recut spans the two original row intervals.

              theorem TauCeti.GridRectangleDecomposition.isRecutOfRightEqRight_recut {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hcommon : D.first.right = D.second.right) (hone : D.HasOneCommonSide) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              D.IsRecutOfRightEqRight (D.recut hone hfirst hsecond)

              A decomposition whose rectangles share their terminal side has a recut classified by the right = right side data of the original decomposition.

              When two empty rectangles share their terminal side and the first starts strictly inside the second's column interval, the recut first ends where the original first starts. Its first rectangle has the second's rows; its second spans both row intervals.

              When two empty rectangles share their terminal side and the second starts strictly inside the first's column interval, the recut first runs from the second's initial side to the common terminal side, then from the first's initial side to the second's. Its first rectangle spans both row intervals; its second has the first's rows.

              theorem TauCeti.GridRectangleDecomposition.isRecutOfLeftEqRight_recut {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hcommon : D.first.left = D.second.right) (hone : D.HasOneCommonSide) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              D.IsRecutOfLeftEqRight (D.recut hone hfirst hsecond)

              A decomposition whose first initial side is the second terminal side has a recut classified by the left = right side data of the original decomposition.

              theorem TauCeti.GridRectangleDecomposition.isRecutOfRightEqLeft_recut {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hcommon : D.first.right = D.second.left) (hone : D.HasOneCommonSide) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              D.IsRecutOfRightEqLeft (D.recut hone hfirst hsecond)

              A decomposition whose first terminal side is the second initial side has a recut classified by the right = left side data of the original decomposition.

              theorem TauCeti.GridRectangleDecomposition.hasOneCommonSide_recut {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hone : D.HasOneCommonSide) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              (D.recut hone hfirst hsecond).HasOneCommonSide

              The recut of a decomposition again shares exactly one side column.

              @[simp]
              theorem TauCeti.GridRectangleDecomposition.sideColumns_union_recut {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hone : D.HasOneCommonSide) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              (D.recut hone hfirst hsecond).first.sideColumns ∪ (D.recut hone hfirst hsecond).second.sideColumns = D.first.sideColumns ∪ D.second.sideColumns

              Recutting a decomposition with one common side preserves the union of its three side columns.

              theorem TauCeti.GridRectangleDecomposition.recut_ne {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hone : D.HasOneCommonSide) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              D.recut hone hfirst hsecond ≠ D

              The recut of a decomposition is different from it: the two pass through different intermediate grid states.

              @[simp]
              theorem TauCeti.GridRectangleDecomposition.recut_recut {n : ℕ} {x z : GridState n} (D : GridRectangleDecomposition x z) (hone : D.HasOneCommonSide) (hfirst : D.first.IsEmpty) (hsecond : D.second.IsEmpty) :
              (D.recut hone hfirst hsecond).recut ⋯ ⋯ ⋯ = D

              Recutting is an involution on the two-step decompositions by two empty rectangles sharing exactly one side column.