Documentation

TauCeti.KnotTheory.Grid.Unblocked

The unblocked grid complex GC⁻ #

The fully blocked differential TauCeti.GridDiagram.fullyBlockedDifferential counts only rectangles that avoid every marking, so it forgets the O-markings entirely. The unblocked complex GC⁻ remembers them: it is the free module on grid states over the polynomial ring R[V₀, …, V_{n-1}], one variable V_c for the O-marking of column c, and its differential

∂⁻ x = ∑_y ∑_r V^{O(r)} · y

runs over the empty rectangles r from x to y carrying no X-marking, each weighted by the monomial V^{O(r)} = ∏ V_c over the columns whose O-marking the rectangle covers. This is the theory that survives (de)stabilization and whose homology is a module over R[U]. The simply blocked theory is obtained by setting one selected variable, conventionally V₀, to zero; setting every variable to zero gives the fully blocked count of BlockedRectangle.lean, which is fullyBlockedRectangleCount_eq_constantCoeff.

Two conventions are fixed here.

Which region carries a marking. Markings sit at the centres of their squares, so a rectangle carries the markings of the squares it covers, GridRectangle.coveredSquares, not those of the grid points in its open interior. That is the region the Maslov and Alexander grading changes are computed against in Grading/MarkingCount.lean, and it is the region used throughout this file. It is also the region the marking-avoidance predicate GridRectangle.AvoidsMarkings of the grid differential tests, which is what makes the fully blocked count a specialization of a matrix coefficient here.

Which grading the variables carry. Giving V_c bidegree (-2, -1) makes the differential homogeneous of bidegree (-1, 0): maslovO_sub_two_mul_card_OColumns_eq_maslovO_sub_one and alexander_sub_card_OColumns_eq_alexander say exactly that the term V^{O(r)} · y contributed by a rectangle r from x to y has Maslov grading M_O(x) - 1 and Alexander grading A(x). The Maslov statement needs the rectangle to be empty; the Alexander statement holds for every X-avoiding rectangle.

The differential is defined over an arbitrary commutative coefficient ring. It squares to zero only in characteristic two: over a general ring the rectangle counts must be corrected by a sign assignment, which SignAssignment/Differential.lean does.

Main definitions #

Main results #

References #

This supplies TauCetiRoadmap/CombinatorialHeegaardFloer/README.md, Lane G.3, "The complexes and ∂² = 0", specifically its "Then unblocked GC⁻ over 𝔽₂[V₁,…,Vₙ]" clause, together with the roadmap convention "Fix once whether differentials drop Maslov by 1 and preserve Alexander (unblocked)". The definitions and the bidegree computation follow Ozsváth--Stipsicz--Szabó, Grid Homology for Knots and Links, Chapter 4.6.

@[reducible, inline]
abbrev TauCeti.GridChainMinus (R : Type u_1) [CommSemiring R] (n : ℕ) :
Type u_1

The unblocked chain module GC⁻ of a grid diagram of size n: the free module on grid states over the polynomial ring R[V₀, …, V_{n-1}], with one variable for each O-marking.

Instances For

    The semilinear equivalence on GC⁻ induced by relabeling columns and renaming coefficient variables by the same permutation. Its inverse uses the inverse column permutation.

    Instances For
      @[simp]

      The coefficient of a relabeled and renamed chain at a state is the renamed coefficient at the inverse-relabeled state.

      @[simp]

      Relabeling and renaming send a generator with coefficient a to the relabeled generator with the renamed coefficient.

      @[simp]

      The inverse equivalence relabels columns and coefficient variables by the inverse permutation.

      The coefficient of a relabeled and renamed chain at a relabeled state is the renamed original coefficient.

      The monomials of a relabeled and renamed chain at a relabeled state are the renamed monomials of the original coefficient.

      theorem TauCeti.GridChain.forall_mem_support_relabelRowsEquiv_iff {n : ℕ} (R : Type u_1) [CommSemiring R] (ρ : Equiv.Perm (Fin n)) (c : GridChainMinus R n) (P : GridState n → (Fin n →₀ ℕ) → Prop) :
      (∀ (x : GridState n), ∀ e ∈ (((relabelRowsEquiv ρ) c) x).support, P x e) ↔ ∀ (x : GridState n), ∀ e ∈ (c x).support, P (GridState.relabelRows ρ x) e

      A property holds for every monomial V^e · x of a row-relabeled chain exactly when it holds for the relabeled monomials of the original chain.

      theorem TauCeti.GridChain.forall_mem_support_relabelColumnsRenameEquiv_iff {n : ℕ} (R : Type u_1) [CommSemiring R] (κ : Equiv.Perm (Fin n)) (c : GridChainMinus R n) (P : GridState n → (Fin n →₀ ℕ) → Prop) :
      (∀ (x : GridState n), ∀ e ∈ (((relabelColumnsRenameEquiv R κ) c) x).support, P x e) ↔ ∀ (x : GridState n), ∀ e ∈ (c x).support, P (GridState.relabelColumns κ x) (Finsupp.mapDomain (⇑κ) e)

      A property holds for every monomial V^e · x of a relabeled and renamed chain exactly when it holds for the relabeled and renamed monomials of the original chain.

      noncomputable def TauCeti.GridChain.matrixMap {n : ℕ} (R : Type u_1) [CommSemiring R] (M : GridState n → GridState n → MvPolynomial (Fin n) R) :

      The map on GC⁻ with matrix coefficients M, linear over the polynomial ring: it sends the generator x with coefficient p to ∑ y, p * M x y • y.

      Instances For
        theorem TauCeti.GridChain.matrixMap_single_apply {n : ℕ} (R : Type u_1) [CommSemiring R] (M : GridState n → GridState n → MvPolynomial (Fin n) R) (x y : GridState n) (p : MvPolynomial (Fin n) R) :
        ((matrixMap R M) (Finsupp.single x p)) y = p * M x y

        The matrix coefficients of the map with matrix coefficients M.

        @[simp]
        theorem TauCeti.GridChain.matrixMap_apply_apply {n : ℕ} (R : Type u_1) [CommSemiring R] (M : GridState n → GridState n → MvPolynomial (Fin n) R) (c : GridChainMinus R n) (y : GridState n) :
        ((matrixMap R M) c) y = Finsupp.sum c fun (x : GridState n) (p : MvPolynomial (Fin n) R) => p * M x y

        The coefficient formula for the map with matrix coefficients M on an arbitrary chain.

        The map on GC⁻ with matrix coefficients M, semilinear over the renaming of the variables by σ: it sends the generator x with coefficient p to ∑ y, rename σ p * M x y • y.

        Instances For
          @[simp]
          theorem TauCeti.GridChain.renameMatrixMap_single {n : ℕ} (R : Type u_1) [CommSemiring R] (σ : Equiv.Perm (Fin n)) (M : GridState n → GridState n → MvPolynomial (Fin n) R) (x : GridState n) (p : MvPolynomial (Fin n) R) :
          (renameMatrixMap R σ M) (Finsupp.single x p) = (MvPolynomial.rename ⇑σ) p • ∑ y : GridState n, Finsupp.single y (M x y)

          The map with matrix coefficients M sends a generator with coefficient p to the renamed coefficient times the row of M at that generator.

          @[simp]
          theorem TauCeti.GridChain.renameMatrixMap_apply_apply {n : ℕ} (R : Type u_1) [CommSemiring R] (σ : Equiv.Perm (Fin n)) (M : GridState n → GridState n → MvPolynomial (Fin n) R) (c : GridChainMinus R n) (y : GridState n) :
          ((renameMatrixMap R σ M) c) y = Finsupp.sum c fun (x : GridState n) (p : MvPolynomial (Fin n) R) => (MvPolynomial.rename ⇑σ) p * M x y

          The coefficient formula for the map with matrix coefficients M on an arbitrary chain.

          theorem TauCeti.GridChain.exists_eq_mapDomain_add_of_mem_support_sum_rename_mul {n : ℕ} (R : Type u_1) [CommSemiring R] (c : GridChainMinus R n) (σ : Equiv.Perm (Fin n)) (M : GridState n → GridState n → MvPolynomial (Fin n) R) {y : GridState n} {e : Fin n →₀ ℕ} (he : e ∈ (Finsupp.sum c fun (x : GridState n) (p : MvPolynomial (Fin n) R) => (MvPolynomial.rename ⇑σ) p * M x y).support) :
          ∃ (x : GridState n), ∃ d ∈ (c x).support, ∃ w ∈ (M x y).support, e = Finsupp.mapDomain (⇑σ) d + w

          A monomial of the coefficient at y of GridChain.renameMatrixMap R σ M c comes from a monomial of an input coefficient c x and a monomial of the matrix entry M x y; its exponent is the σ-renaming of the former plus the latter.

          The diagonal gauge automorphism #

          noncomputable def TauCeti.GridChain.gaugeEquiv {n : ℕ} (R : Type u_1) [CommRing R] (f : GridState n → ℤˣ) :

          The diagonal automorphism of GC⁻ multiplying the generator of each grid state x by the sign f x. It is its own inverse.

          Instances For
            @[simp]
            theorem TauCeti.GridChain.gaugeEquiv_single {n : ℕ} (R : Type u_1) [CommRing R] (f : GridState n → ℤˣ) (x : GridState n) (a : MvPolynomial (Fin n) R) :
            (gaugeEquiv R f) (Finsupp.single x a) = Finsupp.single x (↑(f x) • a)

            The gauge automorphism multiplies the generator of a grid state by its sign.

            @[simp]
            theorem TauCeti.GridChain.gaugeEquiv_apply_apply {n : ℕ} (R : Type u_1) [CommRing R] (f : GridState n → ℤˣ) (c : GridChainMinus R n) (y : GridState n) :
            ((gaugeEquiv R f) c) y = ↑(f y) • c y

            The gauge automorphism multiplies the coefficient of each grid state y by its sign.

            @[simp]
            theorem TauCeti.GridChain.gaugeEquiv_symm {n : ℕ} (R : Type u_1) [CommRing R] (f : GridState n → ℤˣ) :

            The gauge automorphism is its own inverse.

            The O-monomial of a rectangle #

            noncomputable def TauCeti.GridDiagram.OColumnsOfSquares {n : ℕ} (G : GridDiagram n) (s : Finset (Fin n × Fin n)) :

            The columns whose O-marking belongs to a given set of squares.

            Instances For
              @[simp]

              A column belongs to OColumnsOfSquares exactly when its O-marking belongs to the given set of squares.

              The O-markings in a set of squares are exactly those indexed by its covered O-columns.

              The number of covered O-columns is the number of O-markings in a set of squares.

              theorem TauCeti.GridDiagram.prod_ite_OSet_eq_prod_OColumnsOfSquares {n : ℕ} (G : GridDiagram n) {M : Type u_1} [CommMonoid M] (f : Fin n → M) (S : Finset (Fin n × Fin n)) :
              (∏ p ∈ S, if p ∈ G.OSet then f p.1 else 1) = ∏ c ∈ G.OColumnsOfSquares S, f c

              A product over marked squares is the product of the corresponding column factors over its covered O-columns.

              theorem TauCeti.GridDiagram.disjoint_and_prod_OSet_eq_of_union_inter_eq {n : ℕ} (G : GridDiagram n) {M : Type u_1} [CommMonoid M] (f : Fin n → M) (A B S T : Finset (Fin n × Fin n)) (hu : A ∪ B = S ∪ T) (hi : A ∩ B = S ∩ T) (hA : Disjoint A G.XSet) (hB : Disjoint B G.XSet) :
              Disjoint S G.XSet ∧ Disjoint T G.XSet ∧ ((∏ p ∈ A, if p ∈ G.OSet then f p.1 else 1) * ∏ p ∈ B, if p ∈ G.OSet then f p.1 else 1) = (∏ p ∈ S, if p ∈ G.OSet then f p.1 else 1) * ∏ p ∈ T, if p ∈ G.OSet then f p.1 else 1

              Preserving the union and intersection of two square sets transfers X-avoidance and preserves the product of their O-weights in any commutative monoid, including square multiplicities.

              theorem TauCeti.GridDiagram.prod_OColumnsOfSquares_union_singleton_product {n : ℕ} (G : GridDiagram n) {M : Type u_1} [CommMonoid M] (f : Fin n → M) (i j : Fin n) (S T : Finset (Fin n)) (hij : i ≠ j) :
              ∏ c ∈ G.OColumnsOfSquares ({i} ×ˢ S ∪ {j} ×ˢ T), f c = (if G.O.toPerm i ∈ S then f i else 1) * if G.O.toPerm j ∈ T then f j else 1

              A domain supported in two distinct columns contributes each column's factor exactly when its O-marking lies in the prescribed row set.

              theorem TauCeti.GridDiagram.prod_OColumnsOfSquares_product_singleton {n : ℕ} (G : GridDiagram n) {M : Type u_1} [CommMonoid M] (f : Fin n → M) (T : Finset (Fin n)) (s : Fin n) :
              ∏ d ∈ G.OColumnsOfSquares (T ×ˢ {s}), f d = if G.O.transpose.toPerm s ∈ T then f (G.O.transpose.toPerm s) else 1

              A domain supported in one row contributes its unique O-marking's factor exactly when the column containing that marking belongs to the prescribed column set.

              theorem TauCeti.GridDiagram.prod_OColumnsOfSquares_univ_erase_product_singleton {n : ℕ} (G : GridDiagram n) {M : Type u_1} [CommMonoid M] (f : Fin n → M) (c s : Fin n) :
              ∏ d ∈ G.OColumnsOfSquares (Finset.univ.erase c ×ˢ {s}), f d = if G.O.toPerm c = s then 1 else f (G.O.transpose.toPerm s)

              A row with one column omitted contributes its unique O-marking's factor unless that marking lies in the omitted column.

              @[simp]

              The O-markings covered by a union of sets of squares are those covered by either set.

              @[simp]

              The O-markings covered by an intersection of sets of squares are those covered by both sets.

              theorem TauCeti.GridDiagram.prod_OColumnsOfSquares_union_inter {n : ℕ} (G : GridDiagram n) {M : Type u_1} [CommMonoid M] (f : Fin n → M) (A B : Finset (Fin n × Fin n)) :
              (∏ c ∈ G.OColumnsOfSquares (A ∪ B), f c) * ∏ c ∈ G.OColumnsOfSquares (A ∩ B), f c = (∏ c ∈ G.OColumnsOfSquares A, f c) * ∏ c ∈ G.OColumnsOfSquares B, f c

              A product over the covered O-columns of two sets of squares, counted with multiplicity, is the product over the covered O-columns of their union and of their intersection. So the O-markings two sets of squares carry depend only on their union and their intersection.

              noncomputable def TauCeti.GridDiagram.OColumns {n : ℕ} (G : GridDiagram n) (r : GridRectangle n) :

              The columns whose O-marking lies in the squares a toroidal rectangle covers.

              The O-markings of a grid diagram are indexed by their columns, so this finite set of columns is the index set of the variables occurring in the rectangle's weight.

              Instances For

                The O-columns of a rectangle are those of the squares it covers.

                @[simp]

                A column is a covered O-column exactly when its O-marking is a covered square.

                Swapping two columns carries the covered O-columns of a rectangle to their images under the same swap, provided the rectangle either covers both columns or covers neither.

                The number of covered O-columns is the number of O-markings among the covered squares: a grid diagram has exactly one O-marking in each column.

                A rectangle covers no O-column exactly when its covered squares carry no O-marking.

                noncomputable def TauCeti.GridDiagram.OMonomialOfSquares {n : ℕ} (G : GridDiagram n) (R : Type u_1) [CommSemiring R] (S : Finset (Fin n × Fin n)) :

                The squarefree monomial ∏ V_c over the columns whose O-marking lies in a given set of squares.

                An embedded domain (a rectangle, a hexagon, an annulus) covers each marked square at most once, so every exponent of its Heegaard Floer weight V₀^{O₀(D)} ⋯ V_{n-1}^{O_{n-1}(D)} is 0 or 1, and the weight is this monomial of the squares the domain covers.

                Instances For

                  The monomial of a set of squares is the product of the variables of its O-columns.

                  The monomial of a set of squares, written with an explicit exponent vector.

                  The monomial of a set of squares is the product, over the squares, of the variable of the square's column at the O-marked squares and of 1 elsewhere.

                  The monomial of a set of squares carrying no O-marking is 1.

                  @[simp]

                  The monomial of the empty set of squares is 1.

                  The monomial of a set of squares is never zero.

                  The monomial of a set of squares has total degree the number of O-markings lying in the squares (the columns whose O-square belongs to the set).

                  The monomials of the union and of the intersection of two sets of squares multiply to the product of their monomials.

                  The monomial of a union of two disjoint sets of squares is the product of their monomials.

                  noncomputable def TauCeti.GridDiagram.OMonomial {n : ℕ} (G : GridDiagram n) (R : Type u_1) [CommSemiring R] (r : GridRectangle n) :

                  The weight of a toroidal rectangle in the unblocked differential: the squarefree monomial ∏ V_c over the columns whose O-marking the rectangle covers, GridDiagram.OMonomialOfSquares of the squares it covers.

                  Instances For

                    The weight of a rectangle is the monomial of the squares it covers.

                    The weight of a rectangle is the product of the variables of its O-columns.

                    The rectangle monomial of a column-swapped diagram renames the variables of the original monomial by the same swap, provided the rectangle either covers both columns or covers neither.

                    The weight of a rectangle covering no O-marking is 1.

                    The weight of a rectangle, written as a monomial with an explicit exponent vector.

                    theorem TauCeti.GridDiagram.exists_mem_of_mem_support_sum_OMonomial {n : ℕ} (G : GridDiagram n) (R : Type u_1) [CommSemiring R] {x y : GridState n} {s : Finset (GridRectangleBetween x y)} {d : Fin n →₀ ℕ} (hd : d ∈ (∑ r ∈ s, G.OMonomial R r.toGridRectangle).support) :
                    ∃ r ∈ s, d = ∑ c ∈ G.OColumns r.toGridRectangle, Finsupp.single c 1

                    Every monomial of a sum of rectangle weights is the weight of one of the summed rectangles.

                    The weight of a rectangle is never zero.

                    The weight of a rectangle is the product, over the squares it covers, of the variable of the square's column at the O-marked squares and of 1 elsewhere.

                    Written this way the weight is a multiplicative function of the covered-square domain alone, so any repartition of a union of covered squares into rectangles preserves the product of the weights. That is what the recutting arguments for ∂⁻ ∘ ∂⁻ = 0 need.

                    The weight of a rectangle has total degree the number of O-markings the rectangle covers.

                    With each variable V_c in Maslov degree -2 and Alexander degree -1, this says that the weight shifts the two gradings of the target generator by -2 and -1 times the number of covered O-markings.

                    The rectangles the unblocked differential counts #

                    The rectangles counted by the unblocked differential from x to y: the empty rectangles whose covered squares carry no X-marking.

                    Unlike the fully blocked count, O-markings are not forbidden; a covered O-marking is recorded by the variable V_c in the rectangle's weight instead.

                    Instances For
                      @[simp]

                      Membership in the unblocked rectangle set is emptiness together with X-avoidance.

                      Every rectangle the unblocked differential counts is empty.

                      Every rectangle the unblocked differential counts covers no X-marking.

                      A rectangle the unblocked differential counts covers no X-marking square.

                      The rectangles the unblocked differential counts are empty rectangles.

                      At most two rectangles contribute to each matrix coefficient of the unblocked differential.

                      @[simp]

                      There is no rectangle from a grid state to itself, so the unblocked differential has no diagonal term.

                      @[simp]

                      Every rectangle leaving the X-marking state G.X, the grid state whose points are the lower-left corners of the X-marked squares, covers the X-marking at its own lower-left corner, so the unblocked differential counts no rectangle from G.X.

                      Rectangles into the X-marking state of a cyclic-shift grid #

                      When the X-marking permutation is a power of the cyclic shift finRotate n, as it is for the standard torus link grids, powers of the shift preserve the cyclic intervals of the grid (Grid.mem_cIco_finRotate_pow_finRotate_pow), which pins down every rectangle into the X-marking state G.X. Such a rectangle has its two G.X-corners at the upper-left and lower-right, so its rows form the cyclic interval from G.X of its right column to G.X of its left column, while the X-markings of its covered columns occupy the complementary interval. Hence it avoids the X-markings and contains no point of its source state in its interior, so the unblocked differential counts every rectangle into G.X, of which each grid state has none or two.

                      When the X-marking permutation is a power of the cyclic shift, a rectangle into the X-marking state covers no X-marking: the X-markings of its covered columns lie in the cyclic interval of rows complementary to the one it covers.

                      When the X-marking permutation is a power of the cyclic shift, a rectangle into the X-marking state is empty: the points of its source state in the columns strictly between its sides are X-corners, which lie in the cyclic interval of rows complementary to the one it spans.

                      When the X-marking permutation is a power of the cyclic shift, the unblocked differential counts every rectangle into the X-marking state.

                      When the X-marking permutation is a power of the cyclic shift, every grid state has an even number, zero or two, of rectangles into the X-marking state counted by the unblocked differential.

                      The unblocked complex and its differential #

                      noncomputable def TauCeti.GridDiagram.unblockedCoefficient {n : ℕ} (G : GridDiagram n) (R : Type u_1) [CommSemiring R] (x y : GridState n) :

                      The matrix coefficient of the unblocked differential from x to y: the sum of the weights of the empty rectangles from x to y that carry no X-marking.

                      Instances For

                        The matrix coefficient is the sum of the weights of its contributing rectangles.

                        @[simp]

                        The unblocked differential has no diagonal matrix coefficient.

                        The constant term of a sum of rectangle weights counts the rectangles carrying no O-marking: the weight of such a rectangle is 1, and every other weight has a variable factor.

                        The constant term of a matrix coefficient of the unblocked differential counts those contributing rectangles that carry no O-marking either.

                        This is the count obtained by setting every variable to zero; fullyBlockedRectangles_eq_filter identifies the rectangles it counts with the fully blocked ones.

                        The rectangles the unblocked differential counts with trivial weight are exactly the fully blocked ones: both sets consist of the empty rectangles covering no X-marking, and covering no O-marking is the remaining fully blocked condition.

                        @[simp]

                        The constant term of a matrix coefficient of the unblocked differential is the number of fully blocked rectangles it counts.

                        The fully blocked matrix coefficient is the constant term of the unblocked one: blocking every O-marking is setting every variable to zero.

                        Every monomial occurring in a matrix coefficient of the unblocked differential is the weight of one of the rectangles that coefficient counts.

                        The value of the unblocked differential on a single grid-state generator.

                        Instances For
                          @[simp]

                          The y-coefficient of the unblocked differential on the generator x.

                          There is no self-term in the unblocked differential of a generator.

                          The unblocked differential of a generator is supported on the column transpositions of that generator: only a state differing from x in exactly two columns, where the two states exchange rows, can receive a rectangle.

                          The unblocked grid differential ∂⁻, as a linear map on GC⁻ over the polynomial ring.

                          Instances For
                            @[simp]

                            The unblocked differential sends a single generator to the corresponding row of weights.

                            The matrix coefficient of the unblocked differential on a single generator is the sum of the weights of the contributing rectangles.

                            @[simp]

                            Setting every variable to zero in the unblocked differential gives the fully blocked differential.

                            @[simp]

                            Taking constant coefficients intertwines the unblocked and fully blocked differentials.

                            A grid state that no counted rectangle leaves is a cycle of GC⁻.

                            The X-marking state is a cycle of GC⁻.

                            @[simp]

                            The row of ∂⁻ at the X-marking state vanishes: the X-marking state is a cycle of GC⁻.

                            The unblocked differential is the finite sum of its generator rows over the support of a chain.

                            @[simp]

                            The coefficient formula for the unblocked differential on an arbitrary chain.

                            The matrix of the square of the unblocked differential: its (x, z) entry is the sum over intermediate grid states of the products of the two matrix coefficients.

                            The bidegree of the unblocked differential #

                            A rectangle counted by the unblocked differential drops the O-Maslov grading by one, once its weight V^{O(r)} is charged -2 per variable.

                            With V_c in Maslov degree -2, the term V^{O(r)} · y of ∂⁻ x has Maslov grading M_O(x) - 1: the unblocked differential lowers the Maslov grading by exactly one.

                            A rectangle counted by the unblocked differential preserves the Alexander grading, once its weight V^{O(r)} is charged -1 per variable.

                            With V_c in Alexander degree -1, the term V^{O(r)} · y of ∂⁻ x has Alexander grading A(x). Unlike the Maslov statement, this uses only that the rectangle carries no X-marking.