Documentation

DerivedAlgGeo.Algebra.MvPolynomial.Cech.Homotopy

The block homotopy on the variable Čech cover #

The block projections and the contracting homotopy of #340 live at monomial denominators Xᵞ, while the Čech complex of the variable cover names its denominators as products ∏ₐ X_{x a}. The two are equal ring elements, and this file carries the whole toolkit across that equality: tupleExponent is the exponent vector of a Čech tuple, DegreeZeroLocalization.powersCongr transports a degree-zero localization along an equality of denominators, and the Čech-level cechBlockProj and cechHomotopy are the monomial-level maps conjugated by that transport.

The payoff is the three identities the vanishing computation runs on, now stated against polynomialVariableCechFace itself:

together with sum_cechBlockProj (the finitely many blocks of a tuple exhaust its term) and cechBlockProj_eq_zero_of_not_subset (a block off the tuple's support is zero), which are what the reassembly of per-block primitives sums over.

Implementation notes #

powersCongr is defined by subst and every one of its equations is proved by subst plus proof irrelevance — the transported element never moves, only its type's name does. The face transport powersCongr_faceMap takes equalities for both denominators and the face's multiplier, because the Čech side multiplies by X i and the monomial side by monomial (single i 1) 1; the two are definitionally equal, but keeping the equality explicit lets one lemma serve every instantiation.

The Fin.cons combinatorics is isolated in two lemmas — the 0-face of a cone tuple is the base tuple, and the j.succ-face of a cone tuple is the cone over the j-face — so the vanishing computation never touches succAbove directly.

Tags #

Čech complex, contracting homotopy, block decomposition, multivariate polynomial

The exponent vector of a Čech tuple #

noncomputable def MvPolynomial.tupleExponent (ι : Type u) {n : ℕ} (x : Fin n → ι) :

The exponent vector of the Čech denominator of a tuple: one for each occurrence of each variable.

Equations
Instances For
    theorem MvPolynomial.tupleDenominator_eq (ι k : Type u) [Field k] {n : ℕ} (x : Fin (n + 1) → ι) :

    The Čech denominator is the monomial with exponent tupleExponent. This is the equality everything in this file transports along.

    theorem MvPolynomial.tupleExponent_cons {ι : Type u} {n : ℕ} (i₀ : ι) (y : Fin n → ι) :

    Prepending a cone point adds one power of its variable.

    theorem MvPolynomial.tupleExponent_succAbove {ι : Type u} {n : ℕ} (x : Fin (n + 2) → ι) (j : Fin (n + 2)) :

    Dropping the j-th index removes one power of its variable. Oriented with the dropped variable on the left, which is the shape the face splittings consume.

    theorem MvPolynomial.tupleDenominator_cons_eq {ι : Type u} (k : Type u) [Field k] {n : ℕ} (i₀ : ι) (y : Fin (n + 1) → ι) :

    The cone denominator in monomial form, split at the cone variable.

    The Fin.cons combinatorics of the cone #

    theorem MvPolynomial.cons_comp_succAbove_zero {ι : Type u} {n : ℕ} (i₀ : ι) (x : Fin (n + 1) → ι) :

    The 0-face of a cone tuple is the base tuple.

    theorem MvPolynomial.cons_comp_succAbove_succ {ι : Type u} {n : ℕ} (i₀ : ι) (x : Fin (n + 2) → ι) (j : Fin (n + 2)) :

    The j.succ-face of a cone tuple is the cone over the j-face.

    The Čech term in monomial form #

    noncomputable def MvPolynomial.cechTermEquiv (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] (𝓜 : ℕ → σM) [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {n : ℕ} (x : Fin (n + 1) → ι) :

    The Čech term of a tuple, presented at the monomial denominator.

    Equations
    Instances For
      theorem MvPolynomial.cechTermEquiv_cechFace (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] (𝓜 : ℕ → σM) [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {n : ℕ} (x : Fin (n + 2) → ι) (j : Fin (n + 2)) (z : ↥(cechTerm ι k 𝓜 (x ∘ j.succAbove))) :
      (cechTermEquiv ι k 𝓜 x) ((cechFace ι k 𝓜 x j) z) = (laurentFace 𝓜 ⋯) ((cechTermEquiv ι k 𝓜 (x ∘ j.succAbove)) z)

      The comparison carries a Čech face to the monomial-level face at the same variable.

      The block projections on Čech terms #

      noncomputable def MvPolynomial.cechBlockProj (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) {n : ℕ} (x : Fin (n + 1) → ι) (F : Finset ι) :
      ↥(cechTerm ι k 𝓜 x) →+ ↥(cechTerm ι k 𝓜 x)

      The block projection of a Čech term: the monomial-level blockProj conjugated by the denominator comparison.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        theorem MvPolynomial.cechBlockProj_apply (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) {n : ℕ} (x : Fin (n + 1) → ι) (F : Finset ι) (z : ↥(cechTerm ι k 𝓜 x)) :
        (cechBlockProj ι k h𝓜 x F) z = (cechTermEquiv ι k 𝓜 x).symm (blockProj h𝓜 (tupleExponent ι x) F ((cechTermEquiv ι k 𝓜 x) z))
        theorem MvPolynomial.sum_cechBlockProj (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) {n : ℕ} (x : Fin (n + 1) → ι) (z : ↥(cechTerm ι k 𝓜 x)) :
        ∑ F ∈ (tupleExponent ι x).support.powerset, (cechBlockProj ι k h𝓜 x F) z = z

        The finitely many blocks of a tuple exhaust its term.

        theorem MvPolynomial.cechBlockProj_cechBlockProj_self (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) {n : ℕ} (x : Fin (n + 1) → ι) (F : Finset ι) (z : ↥(cechTerm ι k 𝓜 x)) :
        (cechBlockProj ι k h𝓜 x F) ((cechBlockProj ι k h𝓜 x F) z) = (cechBlockProj ι k h𝓜 x F) z

        The block projections are idempotent, transported from blockProj_blockProj_self.

        theorem MvPolynomial.cechBlockProj_eq_zero_of_not_subset (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) {n : ℕ} (x : Fin (n + 1) → ι) {F : Finset ι} (h : ¬F ⊆ (tupleExponent ι x).support) (z : ↥(cechTerm ι k 𝓜 x)) :
        (cechBlockProj ι k h𝓜 x F) z = 0

        A block off the tuple's support is zero.

        theorem MvPolynomial.cechFace_cechBlockProj (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) {n : ℕ} (x : Fin (n + 2) → ι) (j : Fin (n + 2)) (F : Finset ι) (z : ↥(cechTerm ι k 𝓜 (x ∘ j.succAbove))) :
        (cechFace ι k 𝓜 x j) ((cechBlockProj ι k h𝓜 (x ∘ j.succAbove) F) z) = (cechBlockProj ι k h𝓜 x F) ((cechFace ι k 𝓜 x j) z)

        The Čech faces commute with the block projections. The transported form of laurentFace_blockProj: the differential preserves every block.

        The homotopy map on Čech terms #

        noncomputable def MvPolynomial.cechHomotopy (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) (i₀ : ι) {n : ℕ} (y : Fin (n + 1) → ι) :
        ↥(cechTerm ι k 𝓜 (Fin.cons i₀ y)) →+ ↥(cechTerm ι k 𝓜 y)

        The homotopy map on Čech terms: the monomial-level laurentHomotopy conjugated by the denominator comparisons of the cone tuple and the base tuple.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          theorem MvPolynomial.cechHomotopy_apply (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) (i₀ : ι) {n : ℕ} (y : Fin (n + 1) → ι) (z : ↥(cechTerm ι k 𝓜 (Fin.cons i₀ y))) :
          (cechHomotopy ι k h𝓜 i₀ y) z = (cechTermEquiv ι k 𝓜 y).symm ((laurentHomotopy h𝓜 i₀ (tupleExponent ι y)) ((GradedModule.DegreeZeroLocalization.powersCongr ⋯) z))

          Transport along an equality of tuples #

          The faces of a cone tuple land at tuples like (i₀ :: x) ∘ (j.succ).succAbove, which equal i₀ :: (x ∘ j.succAbove) only propositionally. The transport, and the one dependent-rewriting lemma every use reduces to: a cochain takes transported values at equal tuples.

          noncomputable def MvPolynomial.cechTermCongr (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] (𝓜 : ℕ → σM) [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {n : ℕ} {x₁ x₂ : Fin (n + 1) → ι} (h : x₁ = x₂) :
          ↥(cechTerm ι k 𝓜 x₁) ≃+ ↥(cechTerm ι k 𝓜 x₂)

          Transport a Čech term along an equality of tuples.

          Equations
          Instances For
            theorem MvPolynomial.cechTermCongr_apply_section (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] (𝓜 : ℕ → σM) [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {n : ℕ} (s : (x : Fin (n + 1) → ι) → ↥(cechTerm ι k 𝓜 x)) {x₁ x₂ : Fin (n + 1) → ι} (h : x₁ = x₂) :
            (cechTermCongr ι k 𝓜 h) (s x₁) = s x₂

            A cochain takes transported values at equal tuples. This is the whole of the dependent rewriting the vanishing computation needs.

            theorem MvPolynomial.cechTermCongr_symm_apply_section (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] (𝓜 : ℕ → σM) [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {n : ℕ} (s : (x : Fin (n + 1) → ι) → ↥(cechTerm ι k 𝓜 x)) {x₁ x₂ : Fin (n + 1) → ι} (h : x₁ = x₂) :
            (cechTermCongr ι k 𝓜 h).symm (s x₂) = s x₁
            theorem MvPolynomial.cechTermCongr_cechBlockProj (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) {n : ℕ} {x₁ x₂ : Fin (n + 1) → ι} (h : x₁ = x₂) (F : Finset ι) (z : ↥(cechTerm ι k 𝓜 x₁)) :
            (cechTermCongr ι k 𝓜 h) ((cechBlockProj ι k h𝓜 x₁ F) z) = (cechBlockProj ι k h𝓜 x₂ F) ((cechTermCongr ι k 𝓜 h) z)

            The block projections commute with tuple transport.

            The homotopy identities on Čech terms #

            theorem MvPolynomial.laurentHomotopy_laurentFace_comm' {ι k : Type u} [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) (i₀ e : ι) {γ₀ γx : ι →₀ ℕ} (hγx : γx = γ₀ + Finsupp.single e 1) (htop : Finsupp.single i₀ 1 + γx = Finsupp.single e 1 + (Finsupp.single i₀ 1 + γ₀)) (hbot : γx = Finsupp.single e 1 + γ₀) (z : ↥(GradedModule.DegreeZeroLocalization (polynomialGrading ι k) 𝓜 (Submonoid.powers ((monomial (Finsupp.single i₀ 1 + γ₀)) 1)))) :
            (laurentHomotopy h𝓜 i₀ γx) ((laurentFace 𝓜 htop) z) = (laurentFace 𝓜 hbot) ((laurentHomotopy h𝓜 i₀ γ₀) z)

            laurentHomotopy_laurentFace_comm with the enlarged denominator's exponent named by a hypothesis rather than fixed as γ₀ + single e 1. The Čech caller's exponent is tupleExponent x, which equals that sum only propositionally.

            theorem MvPolynomial.cechHomotopy_cechFace_zero (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) (i₀ : ι) {F : Finset ι} (hi₀ : i₀ ∉ F) {n : ℕ} (y : Fin (n + 1) → ι) (z : ↥(cechTerm ι k 𝓜 y)) :
            (cechHomotopy ι k h𝓜 i₀ y) ((cechFace ι k 𝓜 (Fin.cons i₀ y) 0) ((cechTermCongr ι k 𝓜 ⋯).symm ((cechBlockProj ι k h𝓜 y F) z))) = (cechBlockProj ι k h𝓜 y F) z

            The homotopy retracts the cone face on a block. The Čech form of laurentHomotopy_laurentFace_blockProj: for i₀ ∉ F, restricting a block-F element of the base tuple along the 0-face of the cone tuple and applying the homotopy gives it back. The transport on the face's input names the tuple identity (i₀ :: y) ∘ δ₀ = y.

            theorem MvPolynomial.cechHomotopy_cechFace_succ (ι k : Type u) [Field k] {σM : Type u} [SetLike σM (MvPolynomial ι k)] [AddSubgroupClass σM (MvPolynomial ι k)] {𝓜 : ℕ → σM} [SetLike.GradedSMul (polynomialGrading ι k) 𝓜] {d : ℤ} (h𝓜 : IsPolynomialTwist 𝓜 d) (i₀ : ι) {n : ℕ} (x : Fin (n + 2) → ι) (j : Fin (n + 2)) (z : ↥(cechTerm ι k 𝓜 (Fin.cons i₀ (x ∘ j.succAbove)))) :
            (cechHomotopy ι k h𝓜 i₀ x) ((cechFace ι k 𝓜 (Fin.cons i₀ x) j.succ) ((cechTermCongr ι k 𝓜 ⋯).symm z)) = (cechFace ι k 𝓜 x j) ((cechHomotopy ι k h𝓜 i₀ (x ∘ j.succAbove)) z)

            The homotopy commutes with every other face. The Čech form of laurentHomotopy_laurentFace_comm, with no restriction on the block or the face's variable. The transport on the face's input names the tuple identity (i₀ :: x) ∘ δ_{j.succ} = i₀ :: (x ∘ δⱼ).