diff --git a/Rigid.lean b/Rigid.lean index 2d3e20f..b45045b 100644 --- a/Rigid.lean +++ b/Rigid.lean @@ -2,11 +2,21 @@ import Rigid.AffinoidAlgebra.AutomaticContinuity import Rigid.AffinoidAlgebra.BanachRealization import Rigid.AffinoidAlgebra.Basic import Rigid.AffinoidAlgebra.ClosedIdeals +import Rigid.AffinoidAlgebra.CofiniteLinearRecurrence import Rigid.AffinoidAlgebra.CompletedLaurent +import Rigid.AffinoidAlgebra.CompletedLaurentInjective +import Rigid.AffinoidAlgebra.CompletedLaurentQuotient +import Rigid.AffinoidAlgebra.CompletedLaurentRelation +import Rigid.AffinoidAlgebra.CompletedLaurentTwoVariable +import Rigid.AffinoidAlgebra.CompletedLaurentTwoVariableQuotient +import Rigid.AffinoidAlgebra.CompletedLaurentTwoVariableRelation import Rigid.AffinoidAlgebra.FiniteExtensionFunctional import Rigid.AffinoidAlgebra.FiniteModuleBounded import Rigid.AffinoidAlgebra.LaurentCharts import Rigid.AffinoidAlgebra.LaurentCover +import Rigid.AffinoidAlgebra.LaurentCoverExact +import Rigid.AffinoidAlgebra.LaurentIntersection +import Rigid.AffinoidAlgebra.LaurentIntersectionMaps import Rigid.AffinoidAlgebra.MaximalSpectrum import Rigid.AffinoidAlgebra.MaximumModulus import Rigid.AffinoidAlgebra.NoetherNormalization @@ -25,10 +35,26 @@ import Rigid.AffinoidAlgebra.SpectralPolynomial import Rigid.AffinoidAlgebra.SpectralPresentation import Rigid.AffinoidAlgebra.SpectralRadius import Rigid.AffinoidAlgebra.TateRealization +import Rigid.AffinoidSpectrum.Cech +import Rigid.AffinoidSpectrum.CechComparison +import Rigid.AffinoidSpectrum.CechRebase +import Rigid.AffinoidSpectrum.CechRefinement +import Rigid.AffinoidSpectrum.CechRestriction +import Rigid.AffinoidSpectrum.CoverProduct +import Rigid.AffinoidSpectrum.DominatingCover +import Rigid.AffinoidSpectrum.GeneratedCoverReduction +import Rigid.AffinoidSpectrum.GeneratedRestriction +import Rigid.AffinoidSpectrum.LaurentCech +import Rigid.AffinoidSpectrum.LaurentProduct +import Rigid.AffinoidSpectrum.LaurentRestriction import Rigid.AffinoidSpectrum.RationalBasis import Rigid.AffinoidSpectrum.RationalCover +import Rigid.AffinoidSpectrum.RationalPresheaf +import Rigid.AffinoidSpectrum.RationalRebase import Rigid.AffinoidSpectrum.RationalRefinement import Rigid.AffinoidSpectrum.Restriction +import Rigid.AffinoidSpectrum.TateAcyclicity +import Rigid.AffinoidSpectrum.UnitGeneratedCover import Rigid.Berkovich.AffinoidDomain import Rigid.Berkovich.CompletedResidue import Rigid.Berkovich.CompletedResidueFunctoriality @@ -44,6 +70,18 @@ import Rigid.Berkovich.SpectralRadius import Rigid.Berkovich.SpectralSeminorm import Rigid.Berkovich.Spectrum import Rigid.Berkovich.Unit +import Rigid.Cech.Coface +import Rigid.Cech.Comparison +import Rigid.Cech.Contracting +import Rigid.Cech.Double +import Rigid.Cech.DoubleComparison +import Rigid.Cech.DoubleTranspose +import Rigid.Cech.Fiber +import Rigid.Cech.Normalized +import Rigid.Cech.Presheaf +import Rigid.Cech.Refinement +import Rigid.Cech.RefinementContracting +import Rigid.Cech.StrictTuple import Rigid.Development import Rigid.RigidSpace.AdmissibleSite import Rigid.RigidSpace.Basic diff --git a/Rigid/AffinoidAlgebra/CofiniteLinearRecurrence.lean b/Rigid/AffinoidAlgebra/CofiniteLinearRecurrence.lean new file mode 100644 index 0000000..430ceaf --- /dev/null +++ b/Rigid/AffinoidAlgebra/CofiniteLinearRecurrence.lean @@ -0,0 +1,196 @@ +import Mathlib.LinearAlgebra.Charpoly.Basic +import Mathlib.Analysis.Normed.Field.Basic +import Mathlib.Analysis.Normed.Group.Ultra +import Mathlib.Topology.Algebra.Module.FiniteDimension +import Mathlib.Topology.Algebra.InfiniteSum.Nonarchimedean + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# Vanishing of restricted linear recurrences + +A bi-infinite sequence in a finite-dimensional nonarchimedean normed space which tends to zero +along the cofinite filter cannot be an orbit of a linear endomorphism unless it is zero. This is +the finite-dimensional input used to prove injectivity of multiplication by `ζ - f` on restricted +Laurent coefficients. + +The proof is elementary. Cayley--Hamilton gives a scalar polynomial recurrence. Choose the last +coefficient of largest norm and the last term of largest norm. In the corresponding recurrence, +one summand strictly dominates all the others, contradicting the ultrametric inequality. +-/ + +open Filter +open scoped Topology + +universe u v + +namespace Rigid + +namespace CofiniteLinearRecurrence + +variable {K : Type u} [NontriviallyNormedField K] [IsUltrametricDist K] +variable {V : Type v} [NormedAddCommGroup V] [NormedSpace K V] [IsUltrametricDist V] + +private theorem norm_sum_lt + {ι : Type*} (s : Finset ι) (x : ι → V) {r : ℝ} (hr : 0 < r) + (hx : ∀ i ∈ s, ‖x i‖ < r) : + ‖∑ i ∈ s, x i‖ < r := by + classical + induction s using Finset.induction_on with + | empty => simpa using hr + | @insert i s hi ih => + rw [Finset.sum_insert hi] + exact (IsUltrametricDist.norm_add_le_max _ _).trans_lt + (max_lt (hx i (Finset.mem_insert_self i s)) + (ih fun j hj ↦ hx j (Finset.mem_insert_of_mem hj))) + +private theorem polynomial_recurrence_eq_zero + (x : ℤ → V) (hx : Tendsto x cofinite (𝓝 0)) + (p : Polynomial K) (hp : p ≠ 0) + (hrec : ∀ z : ℤ, p.sum (fun n a ↦ a • x (z - n)) = 0) : + ∀ z, x z = 0 := by + classical + by_contra hzero + push Not at hzero + obtain ⟨z₁, hz₁⟩ := hzero + have hr₁ : 0 < ‖x z₁‖ := norm_pos_iff.mpr hz₁ + have heventually : + ∀ᶠ z in (cofinite : Filter ℤ), ‖x z‖ < ‖x z₁‖ := by + have hnorm : Tendsto (fun z ↦ ‖x z‖) cofinite (𝓝 0) := by + simpa using hx.norm + simpa [Real.dist_eq] using + (Metric.tendsto_nhds.mp hnorm ‖x z₁‖ hr₁) + let large : Set ℤ := {z | ‖x z₁‖ ≤ ‖x z‖} + have hlarge : large.Finite := by + have hcompl : largeᶜ ∈ (cofinite : Filter ℤ) := by + simpa [large, Set.compl_setOf, not_le] using heventually + simpa using mem_cofinite.mp hcompl + have hz₁large : z₁ ∈ large := by + change ‖x z₁‖ ≤ ‖x z₁‖ + exact le_rfl + obtain ⟨z₂, hz₂large, hz₂max⟩ := + Set.exists_max_image large (fun z ↦ ‖x z‖) hlarge ⟨z₁, hz₁large⟩ + have hx_le (z : ℤ) : ‖x z‖ ≤ ‖x z₂‖ := by + by_cases hz : z ∈ large + · exact hz₂max z hz + · have hzlt : ‖x z‖ < ‖x z₁‖ := by + simpa [large, not_le] using hz + exact hzlt.le.trans (hz₂max z₁ hz₁large) + have hz₂ne : x z₂ ≠ 0 := by + intro hz + have : ‖x z₁‖ ≤ 0 := by simpa [hz] using hz₂max z₁ hz₁large + exact (not_le_of_gt hr₁) this + have hr₂ : 0 < ‖x z₂‖ := norm_pos_iff.mpr hz₂ne + let peaks : Set ℤ := {z | ‖x z‖ = ‖x z₂‖} + have hpeaks : peaks.Finite := + hlarge.subset fun z hz ↦ by + change ‖x z₁‖ ≤ ‖x z‖ + rw [hz] + exact hz₂max z₁ hz₁large + have hz₂peak : z₂ ∈ peaks := rfl + obtain ⟨z₀, hz₀peak, hz₀latest⟩ := + Set.exists_max_image peaks id hpeaks ⟨z₂, hz₂peak⟩ + have hx_peak : ‖x z₀‖ = ‖x z₂‖ := hz₀peak + have hx_lt_of_gt {z : ℤ} (hz : z₀ < z) : ‖x z‖ < ‖x z₀‖ := by + rw [hx_peak] + exact lt_of_le_of_ne (hx_le z) fun heq ↦ + (not_le_of_gt hz) (hz₀latest z (by simpa [peaks] using heq)) + have hsupport : p.support.Nonempty := Polynomial.support_nonempty.mpr hp + obtain ⟨j₁, hj₁support, hj₁max⟩ := + Finset.exists_max_image p.support (fun n ↦ ‖p.coeff n‖) hsupport + let dominant := p.support.filter fun n ↦ ‖p.coeff n‖ = ‖p.coeff j₁‖ + have hj₁dominant : j₁ ∈ dominant := by simp [dominant, hj₁support] + obtain ⟨j, hjdominant, hjlatest⟩ := + Finset.exists_max_image dominant id ⟨j₁, hj₁dominant⟩ + have hjsupport : j ∈ p.support := (Finset.mem_filter.mp hjdominant).1 + have hjnorm : ‖p.coeff j‖ = ‖p.coeff j₁‖ := + (Finset.mem_filter.mp hjdominant).2 + have hcoeff_le (i : ℕ) (hi : i ∈ p.support) : + ‖p.coeff i‖ ≤ ‖p.coeff j‖ := by + rw [hjnorm] + exact hj₁max i hi + have hcoeff_lt_of_gt {i : ℕ} (hi : i ∈ p.support) (hji : j < i) : + ‖p.coeff i‖ < ‖p.coeff j‖ := by + refine lt_of_le_of_ne (hcoeff_le i hi) ?_ + intro heq + have hi' : i ∈ dominant := by + rw [Finset.mem_filter] + exact ⟨hi, by simpa [hjnorm] using heq⟩ + exact (not_le_of_gt hji) (hjlatest i hi') + have hjne : p.coeff j ≠ 0 := Polynomial.mem_support_iff.mp hjsupport + have hjpos : 0 < ‖p.coeff j‖ := norm_pos_iff.mpr hjne + have hmainpos : 0 < ‖p.coeff j‖ * ‖x z₀‖ := + mul_pos hjpos (by simpa [hx_peak] using hr₂) + let z : ℤ := z₀ + j + let term : ℕ → V := fun i ↦ p.coeff i • x (z - i) + have hterm_lt (i : ℕ) (hi : i ∈ p.support.erase j) : + ‖term i‖ < ‖term j‖ := by + have hisupport : i ∈ p.support := (Finset.mem_erase.mp hi).2 + have hij : i ≠ j := (Finset.mem_erase.mp hi).1 + rw [show ‖term i‖ = ‖p.coeff i‖ * ‖x (z - i)‖ by + simp [term, norm_smul], + show ‖term j‖ = ‖p.coeff j‖ * ‖x z₀‖ by + simp only [term, z] + have hindex : z₀ + (j : ℤ) - (j : ℤ) = z₀ := by omega + rw [hindex, norm_smul]] + rcases lt_or_gt_of_ne hij with hijlt | hjilt + · have hindex : z₀ < z - i := by + simp only [z] + omega + calc + ‖p.coeff i‖ * ‖x (z - i)‖ ≤ + ‖p.coeff j‖ * ‖x (z - i)‖ := + mul_le_mul_of_nonneg_right (hcoeff_le i hisupport) (norm_nonneg _) + _ < ‖p.coeff j‖ * ‖x z₀‖ := + mul_lt_mul_of_pos_left (hx_lt_of_gt hindex) hjpos + · calc + ‖p.coeff i‖ * ‖x (z - i)‖ ≤ + ‖p.coeff i‖ * ‖x z₀‖ := + mul_le_mul_of_nonneg_left + (by simpa only [hx_peak] using hx_le (z - i)) (norm_nonneg _) + _ < ‖p.coeff j‖ * ‖x z₀‖ := + mul_lt_mul_of_pos_right (hcoeff_lt_of_gt hisupport hjilt) + (by simpa [hx_peak] using hr₂) + have hrest : + ‖∑ i ∈ p.support.erase j, term i‖ < ‖term j‖ := + norm_sum_lt (p.support.erase j) term + (by simpa [term, z, norm_smul] using hmainpos) hterm_lt + have hsum : + term j + ∑ i ∈ p.support.erase j, term i = 0 := by + have hzrec := hrec z + change (∑ i ∈ p.support, term i) = 0 at hzrec + rw [← Finset.sum_erase_add _ _ hjsupport] at hzrec + simpa only [add_comm] using hzrec + have hnormeq : + ‖term j‖ = ‖∑ i ∈ p.support.erase j, term i‖ := by + rw [eq_neg_of_add_eq_zero_left hsum, norm_neg] + exact (ne_of_gt hrest) hnormeq + +/-- A restricted bi-infinite orbit of a linear endomorphism on a finite-dimensional +nonarchimedean normed space vanishes. -/ +theorem eq_zero_of_tendsto_cofinite_zero + [FiniteDimensional K V] (T : V →ₗ[K] V) (x : ℤ → V) + (hx : Tendsto x cofinite (𝓝 0)) + (hT : ∀ z : ℤ, T (x z) = x (z - 1)) : + ∀ z, x z = 0 := by + let p := T.charpoly + apply polynomial_recurrence_eq_zero x hx p T.charpoly_monic.ne_zero + intro z + have hpow (n : ℕ) : (T ^ n) (x z) = x (z - n) := by + induction n with + | zero => simp + | succ n ih => + rw [pow_succ'] + change T ((T ^ n) (x z)) = _ + rw [ih, hT] + congr 1 + omega + have hCH := congrArg (fun L : V →ₗ[K] V ↦ L (x z)) T.aeval_self_charpoly + rw [Polynomial.aeval_endomorphism] at hCH + change p.sum (fun n b ↦ b • (T ^ n) (x z)) = 0 at hCH + simpa only [hpow] using hCH + +end CofiniteLinearRecurrence + +end Rigid diff --git a/Rigid/AffinoidAlgebra/CompletedLaurentInjective.lean b/Rigid/AffinoidAlgebra/CompletedLaurentInjective.lean new file mode 100644 index 0000000..71b11f6 --- /dev/null +++ b/Rigid/AffinoidAlgebra/CompletedLaurentInjective.lean @@ -0,0 +1,113 @@ +import Rigid.AffinoidAlgebra.ClosedIdeals +import Rigid.AffinoidAlgebra.CofiniteLinearRecurrence +import Rigid.AffinoidAlgebra.CompletedLaurentRelation +import Rigid.AffinoidAlgebra.NoetherianBanach +import Rigid.AffinoidAlgebra.SpectralPresentation + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# Injectivity of the completed Laurent relation + +For an affinoid algebra `A`, multiplication by the formal Laurent element `ζ - f` is injective on +restricted Laurent coefficient families. We test a relation modulo every positive power of every +maximal ideal. These quotients are finite-dimensional over the ground field, where +Cayley--Hamilton and the nonarchimedean norm rule out a nonzero bi-infinite orbit tending to zero. +Krull intersection then gives the result in `A`. +-/ + +open Filter +open scoped Topology + +universe u v + +namespace Rigid + +namespace CompletedLaurent + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +/-- Splitting a restricted Laurent family into its nonnegative and strictly negative parts is +unique. -/ +theorem relationFactor_injective : + Function.Injective (relationFactor K A) := by + rintro ⟨p, q⟩ ⟨p', q'⟩ h + apply Prod.ext + · apply TateAlgebra.ext + intro e + have he : e = oneExponent (e 0) := by + apply Finsupp.ext + intro i + rw [Fin.eq_zero i] + simp [oneExponent] + rw [he] + have hcoeff := congrArg + (fun c : Series K A ↦ c.1 (e 0 : ℤ)) h + simpa only [relationFactor_apply_ofNat] using hcoeff + · apply TateAlgebra.ext + intro e + have he : e = oneExponent (e 0) := by + apply Finsupp.ext + intro i + rw [Fin.eq_zero i] + simp [oneExponent] + rw [he] + have hcoeff := congrArg + (fun c : Series K A ↦ c.1 (Int.negSucc (e 0))) h + have hneg : + -TateAlgebra.coeff A (Fin 1) (oneExponent (e 0)) q = + -TateAlgebra.coeff A (Fin 1) (oneExponent (e 0)) q' := by + simpa only [relationFactor_apply_negSucc] using hcoeff + exact neg_injective hneg + +/-- A restricted Laurent family killed by `ζ - f` is zero over an affinoid algebra. -/ +theorem relation_eq_zero + (hA : IsAffinoidAlgebra K A) (f : A) (c : Series K A) + (hc : relation K A f c = 0) : + c = 0 := by + letI : IsNoetherianRing A := isNoetherianRing_of_affinoidAlgebra K hA + apply Subtype.ext + funext z + apply eq_zero_of_mem_all_maximal_powers_of_isAffinoidAlgebra K hA + intro m hm l hl + let I : Ideal A := m ^ l + let Q := A ⧸ I + letI : IsClosed (I : Set A) := isClosed_ideal_of_isNoetherianRing K I + letI : IsUltrametricDist Q := idealQuotientIsUltrametricDist I + letI : Module.Finite K Q := + finite_quotient_maximal_pow_of_isAffinoidAlgebra K hA m hm l hl + let q : ContinuousAlgHom K A Q := idealQuotientMk K I + let x : ℤ → Q := fun w ↦ q (c.1 w) + have hx : Tendsto x cofinite (𝓝 0) := by + have := q.continuous.continuousAt.tendsto.comp c.2 + change Tendsto (q ∘ c.1) cofinite (𝓝 0) at this + change Tendsto (q ∘ c.1) cofinite (𝓝 0) + exact this + let T : Q →ₗ[K] Q := LinearMap.mulLeft K (q f) + have hT (w : ℤ) : T (x w) = x (w - 1) := by + have hw := congrArg (fun d : Series K A ↦ d.1 w) hc + change c.1 (w - 1) - f * c.1 w = 0 at hw + have hqw := congrArg q hw + simp only [map_sub, map_mul, map_zero] at hqw + change q f * q (c.1 w) = q (c.1 (w - 1)) + exact (sub_eq_zero.mp hqw).symm + have hxzero := + CofiniteLinearRecurrence.eq_zero_of_tendsto_cofinite_zero T x hx hT z + change c.1 z ∈ I + exact Ideal.Quotient.eq_zero_iff_mem.mp hxzero + +/-- Multiplication by `ζ - f` on restricted Laurent coefficient families is injective over an +affinoid algebra. -/ +theorem relation_injective + (hA : IsAffinoidAlgebra K A) (f : A) : + Function.Injective (relation K A f) := by + apply (injective_iff_map_eq_zero (relation K A f)).mpr + intro c hc + exact relation_eq_zero K A hA f c hc + +end CompletedLaurent + +end Rigid diff --git a/Rigid/AffinoidAlgebra/CompletedLaurentQuotient.lean b/Rigid/AffinoidAlgebra/CompletedLaurentQuotient.lean new file mode 100644 index 0000000..7a31eca --- /dev/null +++ b/Rigid/AffinoidAlgebra/CompletedLaurentQuotient.lean @@ -0,0 +1,291 @@ +import Rigid.AffinoidAlgebra.BanachRealization +import Rigid.AffinoidAlgebra.CompletedLaurentRelation +import Rigid.AffinoidAlgebra.LaurentCharts +import Rigid.AffinoidAlgebra.SpectralPresentation + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# Quotients in the completed Laurent diagram + +This file identifies the two one-variable quotients in the completed Laurent diagram with the +positive and negative Laurent rational localizations. The only topological point is that the +principal relation ideals are closed: the relative Tate algebras are affinoid, hence Noetherian, +and ideals in a Noetherian nonarchimedean Banach algebra are closed. +-/ + +universe u v + +namespace Rigid + +namespace CompletedLaurent + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +private theorem range_mul_eq_span_singleton_restrictScalars + (r : TateAlgebra A (Fin 1)) + (μ : TateAlgebra A (Fin 1) →ₗ[K] TateAlgebra A (Fin 1)) + (hμ : ∀ p, μ p = r * p) : + LinearMap.range μ = (Ideal.span ({r} : Set (TateAlgebra A (Fin 1)))).restrictScalars K := by + ext x + constructor + · rintro ⟨p, rfl⟩ + change μ p ∈ Ideal.span ({r} : Set (TateAlgebra A (Fin 1))) + rw [hμ] + exact Ideal.mem_span_singleton.mpr ⟨p, by rw [mul_comm]⟩ + · intro hx + change x ∈ Ideal.span ({r} : Set (TateAlgebra A (Fin 1))) at hx + obtain ⟨p, hp⟩ := Ideal.mem_span_singleton.mp hx + refine ⟨p, ?_⟩ + simpa [hμ] using hp.symm + +private theorem relativeTate_isNoetherian (hA : IsAffinoidAlgebra K A) : + IsNoetherianRing (TateAlgebra A (Fin 1)) := by + obtain ⟨m, π, hπ⟩ := + exists_equivalent_quotientNorm_presentation_of_presentation_topology_eq K A + hA.presentation.n hA.presentation.ideal hA.presentation.equiv + (topology_eq_affinoidTopology_of_presentation K A + hA.presentation.n hA.presentation.ideal hA.presentation.equiv) + exact isNoetherianRing_of_affinoidAlgebra K + (isAffinoidAlgebra_relativeTateAlgebra_of_surjective K A m π hπ.surjective 1) + +private theorem plus_generator_range (f : A) : + Set.range (fun i : Fin 1 ↦ + TateAlgebra.C A (Fin 1) (1 : A) * tateVariable A (Fin 1) i - + TateAlgebra.C A (Fin 1) f) = + {tateVariable A (Fin 1) 0 - TateAlgebra.C A (Fin 1) f} := by + ext x + constructor + · rintro ⟨i, rfl⟩ + rw [Fin.eq_zero i] + simp + · rintro (rfl : x = _) + exact ⟨0, by simp⟩ + +private theorem minus_generator_range (f : A) : + Set.range (fun i : Fin 1 ↦ + TateAlgebra.C A (Fin 1) f * tateVariable A (Fin 1) i - + TateAlgebra.C A (Fin 1) (1 : A)) = + {-(1 - TateAlgebra.C A (Fin 1) f * tateVariable A (Fin 1) 0)} := by + ext x + constructor + · rintro ⟨i, rfl⟩ + rw [Fin.eq_zero i] + simp only [Set.mem_singleton_iff, map_one] + ring + · rintro (rfl : x = _) + refine ⟨0, ?_⟩ + simp only [map_one] + ring + +theorem plus_range_eq_rationalLocalizationIdeal_restrictScalars + (hA : IsAffinoidAlgebra K A) (f : A) : + LinearMap.range (plusRelation K A f) = + (rationalLocalizationIdeal A 1 1 (fun _ ↦ f)).restrictScalars K := by + letI : IsNoetherianRing (TateAlgebra A (Fin 1)) := relativeTate_isNoetherian K A hA + let r := tateVariable A (Fin 1) 0 - TateAlgebra.C A (Fin 1) f + have hspanClosed : + IsClosed ((Ideal.span ({r} : Set (TateAlgebra A (Fin 1))) : + Ideal (TateAlgebra A (Fin 1))) : Set (TateAlgebra A (Fin 1))) := + isClosed_ideal_of_isNoetherianRing K _ + rw [rationalLocalizationIdeal, plus_generator_range A f, + Ideal.closure_eq_of_isClosed _ hspanClosed] + exact range_mul_eq_span_singleton_restrictScalars K A r + (plusRelation K A f) (fun _ ↦ rfl) + +theorem minus_range_eq_rationalLocalizationIdeal_restrictScalars + (hA : IsAffinoidAlgebra K A) (f : A) : + LinearMap.range (minusRelation K A f) = + (rationalLocalizationIdeal A 1 f (fun _ ↦ 1)).restrictScalars K := by + letI : IsNoetherianRing (TateAlgebra A (Fin 1)) := relativeTate_isNoetherian K A hA + let r := 1 - TateAlgebra.C A (Fin 1) f * tateVariable A (Fin 1) 0 + have hspanClosed : + IsClosed ((Ideal.span ({-r} : Set (TateAlgebra A (Fin 1))) : + Ideal (TateAlgebra A (Fin 1))) : Set (TateAlgebra A (Fin 1))) := + isClosed_ideal_of_isNoetherianRing K _ + rw [rationalLocalizationIdeal, minus_generator_range A f, + Ideal.closure_eq_of_isClosed _ hspanClosed] + have hneg : + (Ideal.span ({-r} : Set (TateAlgebra A (Fin 1)))).restrictScalars K = + (Ideal.span ({r} : Set (TateAlgebra A (Fin 1)))).restrictScalars K := by + congr 1 + apply le_antisymm + · apply Ideal.span_le.mpr + rintro x (rfl : x = -r) + exact (Ideal.span ({r} : Set (TateAlgebra A (Fin 1)))).neg_mem + (Ideal.mem_span_singleton_self r) + · apply Ideal.span_le.mpr + rintro x (rfl : x = r) + have hnr : + -r ∈ Ideal.span ({-r} : Set (TateAlgebra A (Fin 1))) := + Ideal.mem_span_singleton_self (-r) + change r ∈ Ideal.span ({-r} : Set (TateAlgebra A (Fin 1))) + simpa only [neg_neg] using + (Ideal.span ({-r} : Set (TateAlgebra A (Fin 1)))).neg_mem hnr + rw [hneg] + exact range_mul_eq_span_singleton_restrictScalars K A r + (minusRelation K A f) (fun _ ↦ rfl) + +/-- The product of the two quotient maps defining the positive and negative Laurent charts. -/ +noncomputable def chartQuotientMap (f : A) : + TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1) →ₗ[K] + LaurentCharts.Plus K A f × LaurentCharts.Minus K A f := + (RationalLocalization.quotientMap K A 1 1 (fun _ ↦ f)).toLinearMap.prodMap + (RationalLocalization.quotientMap K A 1 f (fun _ ↦ 1)).toLinearMap + +@[simp] +theorem chartQuotientMap_apply (f : A) + (p q : TateAlgebra A (Fin 1)) : + chartQuotientMap K A f (p, q) = + (RationalLocalization.quotientMap K A 1 1 (fun _ ↦ f) p, + RationalLocalization.quotientMap K A 1 f (fun _ ↦ 1) q) := + rfl + +theorem chartQuotientMap_surjective (f : A) : + Function.Surjective (chartQuotientMap K A f) := by + rintro ⟨p, q⟩ + obtain ⟨p', rfl⟩ := Ideal.Quotient.mk_surjective p + obtain ⟨q', rfl⟩ := Ideal.Quotient.mk_surjective q + exact ⟨(p', q'), rfl⟩ + +theorem ker_chartQuotientMap (hA : IsAffinoidAlgebra K A) (f : A) : + LinearMap.ker (chartQuotientMap K A f) = + LinearMap.range (chartRelations K A f) := by + ext pq + constructor + · intro hpq + have hp : + RationalLocalization.quotientMap K A 1 1 (fun _ ↦ f) pq.1 = 0 := by + have h := LinearMap.mem_ker.mp hpq + exact congrArg Prod.fst h + have hq : + RationalLocalization.quotientMap K A 1 f (fun _ ↦ 1) pq.2 = 0 := by + have h := LinearMap.mem_ker.mp hpq + exact congrArg Prod.snd h + have hp' : + pq.1 ∈ LinearMap.range (plusRelation K A f) := by + rw [plus_range_eq_rationalLocalizationIdeal_restrictScalars K A hA f] + exact Ideal.Quotient.eq_zero_iff_mem.mp hp + have hq' : + pq.2 ∈ LinearMap.range (minusRelation K A f) := by + rw [minus_range_eq_rationalLocalizationIdeal_restrictScalars K A hA f] + exact Ideal.Quotient.eq_zero_iff_mem.mp hq + obtain ⟨p, hp⟩ := hp' + obtain ⟨q, hq⟩ := hq' + refine ⟨(p, q), ?_⟩ + exact Prod.ext hp hq + · rintro ⟨pq', rfl⟩ + apply LinearMap.mem_ker.mpr + rcases pq' with ⟨p, q⟩ + apply Prod.ext + · change Ideal.Quotient.mk + (rationalLocalizationIdeal A 1 1 (fun _ ↦ f)) (plusRelation K A f p) = 0 + apply Ideal.Quotient.eq_zero_iff_mem.mpr + change plusRelation K A f p ∈ + (rationalLocalizationIdeal A 1 1 (fun _ ↦ f)).restrictScalars K + rw [← plus_range_eq_rationalLocalizationIdeal_restrictScalars K A hA f] + exact ⟨p, rfl⟩ + · change Ideal.Quotient.mk + (rationalLocalizationIdeal A 1 f (fun _ ↦ 1)) (minusRelation K A f q) = 0 + apply Ideal.Quotient.eq_zero_iff_mem.mpr + change minusRelation K A f q ∈ + (rationalLocalizationIdeal A 1 f (fun _ ↦ 1)).restrictScalars K + rw [← minus_range_eq_rationalLocalizationIdeal_restrictScalars K A hA f] + exact ⟨q, rfl⟩ + +/-- The quotient of the two completed chart algebras by their relation ranges is the product of +the two Laurent rational localizations. -/ +noncomputable def chartRelationQuotientEquiv + (hA : IsAffinoidAlgebra K A) (f : A) : + ChartRelationQuotient K A f ≃ₗ[K] + LaurentCharts.Plus K A f × LaurentCharts.Minus K A f := + (Submodule.quotEquivOfEq + (LinearMap.range (chartRelations K A f)) + (LinearMap.ker (chartQuotientMap K A f)) + (ker_chartQuotientMap K A hA f).symm).trans + ((chartQuotientMap K A f).quotKerEquivOfSurjective + (chartQuotientMap_surjective K A f)) + +@[simp] +theorem chartRelationQuotientEquiv_mk + (hA : IsAffinoidAlgebra K A) (f : A) + (pq : TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1)) : + chartRelationQuotientEquiv K A hA f (Submodule.Quotient.mk pq) = + chartQuotientMap K A f pq := + rfl + +/-- Remove the harmless quotient by the zero submodule in the source of the descended row. -/ +noncomputable def botQuotientEquiv : (A ⧸ (⊥ : Submodule K A)) ≃ₗ[K] A := + Submodule.quotEquivOfEqBot (⊥ : Submodule K A) rfl + +/-- The diagonal after identifying the chart-relation quotient with the two rational charts. -/ +noncomputable def auxiliaryDiagonal + (hA : IsAffinoidAlgebra K A) (f : A) : + A →ₗ[K] LaurentCharts.Plus K A f × LaurentCharts.Minus K A f := + (chartRelationQuotientEquiv K A hA f).toLinearMap.comp + ((quotientDiagonal K A f).comp (botQuotientEquiv K A).symm.toLinearMap) + +/-- Laurent difference with values in the completed Laurent relation quotient. -/ +noncomputable def auxiliaryDifference + (hA : IsAffinoidAlgebra K A) (f : A) : + LaurentCharts.Plus K A f × LaurentCharts.Minus K A f →ₗ[K] + LaurentRelationQuotient K A f := + (quotientDifference K A f).comp + (chartRelationQuotientEquiv K A hA f).symm.toLinearMap + +@[simp] +theorem auxiliaryDiagonal_apply + (hA : IsAffinoidAlgebra K A) (f a : A) : + auxiliaryDiagonal K A hA f a = LaurentCharts.diagonal K A f a := by + change chartQuotientMap K A f + (TateAlgebra.C A (Fin 1) a, TateAlgebra.C A (Fin 1) a) = + (LaurentCharts.plusMap K A f a, LaurentCharts.minusMap K A f a) + apply Prod.ext <;> rfl + +/-- Exactness at the two chart terms, with the overlap represented by completed Laurent +coefficients modulo `ζ-f`. -/ +theorem auxiliary_exact + (hA : IsAffinoidAlgebra K A) (f : A) : + Function.Exact (LaurentCharts.diagonal K A f) + (auxiliaryDifference K A hA f) := by + have hmiddle : + Function.Exact + ((chartRelationQuotientEquiv K A hA f).toLinearMap.comp + (quotientDiagonal K A f)) + ((quotientDifference K A f).comp + (chartRelationQuotientEquiv K A hA f).symm.toLinearMap) := + (LinearEquiv.conj_exact_iff_exact + (quotientDiagonal K A f) (quotientDifference K A f) + (chartRelationQuotientEquiv K A hA f)).2 + (quotient_exact K A f) + have hsource : + Function.Exact (auxiliaryDiagonal K A hA f) + (auxiliaryDifference K A hA f) := by + simpa only [auxiliaryDiagonal, auxiliaryDifference, LinearMap.comp_assoc] using + (LinearEquiv.precomp_exact_iff_exact + (f := (chartRelationQuotientEquiv K A hA f).toLinearMap.comp + (quotientDiagonal K A f)) + (g := (quotientDifference K A f).comp + (chartRelationQuotientEquiv K A hA f).symm.toLinearMap) + (e := (botQuotientEquiv K A).symm)).mpr hmiddle + have hdiag : + auxiliaryDiagonal K A hA f = LaurentCharts.diagonal K A f := by + apply LinearMap.ext + intro a + exact auxiliaryDiagonal_apply K A hA f a + rw [← hdiag] + exact hsource + +/-- The auxiliary Laurent difference is onto. -/ +theorem auxiliaryDifference_surjective + (hA : IsAffinoidAlgebra K A) (f : A) : + Function.Surjective (auxiliaryDifference K A hA f) := + (quotientDifference_surjective K A f).comp + (chartRelationQuotientEquiv K A hA f).symm.surjective + +end CompletedLaurent + +end Rigid diff --git a/Rigid/AffinoidAlgebra/CompletedLaurentRelation.lean b/Rigid/AffinoidAlgebra/CompletedLaurentRelation.lean new file mode 100644 index 0000000..2890127 --- /dev/null +++ b/Rigid/AffinoidAlgebra/CompletedLaurentRelation.lean @@ -0,0 +1,403 @@ +import Rigid.AffinoidAlgebra.CompletedLaurent +import Rigid.TateAlgebra.Leading + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# The relation row in the completed Laurent diagram + +The proof of Tate acyclicity for a two-member Laurent cover uses the diagram in BGR 8.2.3. +The middle row is the completed Laurent coefficient sequence from +`Rigid.AffinoidAlgebra.CompletedLaurent`. This file supplies the coefficient calculation for the +row above it. + +If `ζ` denotes the Laurent variable, multiplication by `ζ - f` sends a restricted Laurent +coefficient family `c` to the family + +`z ↦ c (z - 1) - f * c z`. + +The image of the two chart relations `(T - f)` and `(1 - fS)` under Laurent difference is exactly +the image of this operator. Surjectivity of the factor map below is the formal version of + +`(ζ - f) A⟨ζ, ζ⁻¹⟩ = + (ζ - f) A⟨ζ⟩ + (1 - fζ⁻¹) A⟨ζ⁻¹⟩`. +-/ + +open Filter +open scoped Topology + +universe u v + +namespace Rigid + +namespace CompletedLaurent + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +private theorem sub_one_injective : Function.Injective (fun z : ℤ ↦ z - 1) := by + intro z w h + have h' := congrArg (fun x : ℤ ↦ x + 1) h + simpa only [sub_add_cancel] using h' + +private theorem add_one_injective : Function.Injective (fun z : ℤ ↦ z + 1) := by + intro z w h + exact add_right_cancel h + +/-- Shift Laurent coefficients up by one exponent. -/ +noncomputable def shift : Series K A →ₗ[K] Series K A where + toFun c := + ⟨fun z ↦ c.1 (z - 1), c.2.comp sub_one_injective.tendsto_cofinite⟩ + map_add' c d := by + ext z + rfl + map_smul' r c := by + ext z + rfl + +/-- Multiplication by the formal Laurent element `ζ - f`. -/ +noncomputable def relation (f : A) : Series K A →ₗ[K] Series K A where + toFun c := + ⟨fun z ↦ c.1 (z - 1) - f * c.1 z, by + change Tendsto (fun z : ℤ ↦ c.1 (z - 1) - f * c.1 z) cofinite (𝓝 0) + have hshift := c.2.comp sub_one_injective.tendsto_cofinite + have hmul : Tendsto (fun z : ℤ ↦ f * c.1 z) cofinite (𝓝 0) := by + simpa only [mul_zero] using (tendsto_const_nhds.mul c.2) + simpa only [Function.comp_apply, mul_zero, sub_zero] using hshift.sub hmul⟩ + map_add' c d := by + ext z + simp only [Submodule.coe_add, Pi.add_apply] + ring + map_smul' r c := by + ext z + change (r • c.1) (z - 1) - f * (r • c.1) z = + r • (c.1 (z - 1) - f * c.1 z) + simp only [Pi.smul_apply] + rw [smul_sub, mul_smul_comm] + +/-- The negative chart shifted once farther into the strictly negative Laurent exponents. -/ +noncomputable def strictNegative : TateAlgebra A (Fin 1) →ₗ[K] Series K A where + toFun q := + ⟨fun z ↦ -(negative K A q).1 (z + 1), by + change Tendsto (fun z : ℤ ↦ -(negative K A q).1 (z + 1)) cofinite (𝓝 0) + have hshift := (negative K A q).2.comp add_one_injective.tendsto_cofinite + simpa only [Function.comp_apply, neg_zero] using hshift.neg⟩ + map_add' p q := by + ext z + simp only [map_add, Submodule.coe_add, Pi.add_apply] + abel + map_smul' r q := by + ext z + simp + +theorem positive_apply_of_nonneg (p : TateAlgebra A (Fin 1)) (z : ℤ) (hz : 0 ≤ z) : + (positive K A p).1 z = + TateAlgebra.coeff A (Fin 1) (oneExponent z.toNat) p := by + change (if 0 ≤ z then TateAlgebra.coeff A (Fin 1) (oneExponent z.toNat) p else 0) = _ + rw [if_pos hz] + +theorem positive_apply_of_neg (p : TateAlgebra A (Fin 1)) (z : ℤ) (hz : z < 0) : + (positive K A p).1 z = 0 := by + change (if 0 ≤ z then TateAlgebra.coeff A (Fin 1) (oneExponent z.toNat) p else 0) = 0 + rw [if_neg (not_le_of_gt hz)] + +@[simp] +theorem negative_apply (q : TateAlgebra A (Fin 1)) (z : ℤ) : + (negative K A q).1 z = (positive K A q).1 (-z) := + rfl + +@[simp] +theorem strictNegative_apply (q : TateAlgebra A (Fin 1)) (z : ℤ) : + (strictNegative K A q).1 z = -(negative K A q).1 (z + 1) := + rfl + +/-- The two chart factors whose relation multiples produce an arbitrary Laurent relation +multiple. The first component supplies the nonnegative coefficients and the second supplies the +strictly negative coefficients. -/ +noncomputable def relationFactor : + TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1) →ₗ[K] Series K A := + (positive K A).comp (LinearMap.fst K _ _) + + (strictNegative K A).comp (LinearMap.snd K _ _) + +@[simp] +theorem relationFactor_apply (p q : TateAlgebra A (Fin 1)) : + relationFactor K A (p, q) = positive K A p + strictNegative K A q := + rfl + +/-- Every restricted Laurent family splits uniquely by support into a nonnegative part and a +strictly negative part. In particular, the factor map used for the relation row is onto. -/ +theorem relationFactor_surjective : Function.Surjective (relationFactor K A) := by + intro a + let pa : ℕ → A := fun n ↦ a.1 (n : ℤ) + have hpa : Tendsto pa cofinite (𝓝 0) := + a.2.comp (show Function.Injective (fun n : ℕ ↦ (n : ℤ)) by + intro n m h + exact Int.ofNat.inj h).tendsto_cofinite + let qa : ℕ → A := fun n ↦ -a.1 (-((n : ℤ) + 1)) + have hindex : Function.Injective (fun n : ℕ ↦ -((n : ℤ) + 1)) := by + intro n m h + have h' : (n : ℤ) + 1 = (m : ℤ) + 1 := neg_inj.mp h + exact Int.ofNat.inj (add_right_cancel h') + have hqa : Tendsto qa cofinite (𝓝 0) := by + have h := a.2.comp hindex.tendsto_cofinite + change Tendsto (fun n : ℕ ↦ -a.1 (-((n : ℤ) + 1))) cofinite (𝓝 0) + simpa only [Function.comp_apply, neg_zero] using h.neg + refine ⟨(ofCoefficients A pa hpa, ofCoefficients A qa hqa), ?_⟩ + ext z + by_cases hz : 0 ≤ z + · obtain ⟨n, rfl⟩ := Int.eq_ofNat_of_zero_le hz + rw [relationFactor_apply] + change (positive K A (ofCoefficients A pa hpa)).1 (n : ℤ) + + (strictNegative K A (ofCoefficients A qa hqa)).1 (n : ℤ) = a.1 (n : ℤ) + rw [positive_apply_of_nonneg K A _ _ (Int.natCast_nonneg n), strictNegative_apply, + negative_apply, positive_apply_of_neg] + · rw [neg_zero, add_zero, Int.toNat_natCast, coeff_ofCoefficients] + · omega + · have hzneg : z < 0 := lt_of_not_ge hz + obtain ⟨n, rfl⟩ := Int.eq_negSucc_of_lt_zero hzneg + rw [relationFactor_apply] + change (positive K A (ofCoefficients A pa hpa)).1 (-((n : ℤ) + 1)) + + (strictNegative K A (ofCoefficients A qa hqa)).1 (-((n : ℤ) + 1)) = + a.1 (-((n : ℤ) + 1)) + rw [positive_apply_of_neg K A, strictNegative_apply, negative_apply] + · have hindex : -(-((n : ℤ) + 1) + 1) = (n : ℤ) := by omega + rw [hindex, positive_apply_of_nonneg K A _ _ (Int.natCast_nonneg n), + Int.toNat_natCast, zero_add, coeff_ofCoefficients] + simp [qa] + · omega + +@[simp] +theorem relation_apply (f : A) (c : Series K A) (z : ℤ) : + (relation K A f c).1 z = c.1 (z - 1) - f * c.1 z := + rfl + +@[simp] +theorem relationFactor_apply_ofNat (p q : TateAlgebra A (Fin 1)) (n : ℕ) : + (relationFactor K A (p, q)).1 (n : ℤ) = + TateAlgebra.coeff A (Fin 1) (oneExponent n) p := by + rw [relationFactor_apply] + change (positive K A p).1 (n : ℤ) + (strictNegative K A q).1 (n : ℤ) = _ + rw [positive_apply_of_nonneg K A _ _ (Int.natCast_nonneg n), strictNegative_apply, + negative_apply, positive_apply_of_neg] + · simp + · omega + +@[simp] +theorem relationFactor_apply_negSucc (p q : TateAlgebra A (Fin 1)) (n : ℕ) : + (relationFactor K A (p, q)).1 (Int.negSucc n) = + -TateAlgebra.coeff A (Fin 1) (oneExponent n) q := by + rw [relationFactor_apply] + change (positive K A p).1 (-((n : ℤ) + 1)) + + (strictNegative K A q).1 (-((n : ℤ) + 1)) = _ + rw [positive_apply_of_neg K A, strictNegative_apply, negative_apply] + · have hindex : -(-((n : ℤ) + 1) + 1) = (n : ℤ) := by omega + rw [hindex, positive_apply_of_nonneg K A _ _ (Int.natCast_nonneg n), + Int.toNat_natCast, zero_add] + · omega + +/-- Multiplication by `T - f` in the positive chart before quotienting. -/ +noncomputable def plusRelation (f : A) : + TateAlgebra A (Fin 1) →ₗ[K] TateAlgebra A (Fin 1) where + toFun p := + (tateVariable A (Fin 1) 0 - TateAlgebra.C A (Fin 1) f) * p + map_add' p q := by rw [mul_add] + map_smul' r p := by + rw [RingHom.id_apply, mul_smul_comm] + +/-- Multiplication by `1 - fS` in the negative chart before quotienting. -/ +noncomputable def minusRelation (f : A) : + TateAlgebra A (Fin 1) →ₗ[K] TateAlgebra A (Fin 1) where + toFun q := + (1 - TateAlgebra.C A (Fin 1) f * tateVariable A (Fin 1) 0) * q + map_add' p q := by rw [mul_add] + map_smul' r p := by + rw [RingHom.id_apply, mul_smul_comm] + +/-- The pair of relation multiplications in the two one-variable Tate algebras. -/ +noncomputable def chartRelations (f : A) : + TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1) →ₗ[K] + TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1) := + (plusRelation K A f).prodMap (minusRelation K A f) + +@[simp] +theorem chartRelations_apply (f : A) (p q : TateAlgebra A (Fin 1)) : + chartRelations K A f (p, q) = (plusRelation K A f p, minusRelation K A f q) := + rfl + +theorem coeff_plusRelation_zero (f : A) (p : TateAlgebra A (Fin 1)) : + TateAlgebra.coeff A (Fin 1) (oneExponent 0) (plusRelation K A f p) = + -f * TateAlgebra.coeff A (Fin 1) (oneExponent 0) p := by + change MvPowerSeries.coeff (oneExponent 0) + (((tateVariable A (Fin 1) 0 - TateAlgebra.C A (Fin 1) f) * p : + TateAlgebra A (Fin 1)) : MvPowerSeries (Fin 1) A) = _ + have hcoe : + ((((tateVariable A (Fin 1) 0 - TateAlgebra.C A (Fin 1) f) * p : + TateAlgebra A (Fin 1)) : MvPowerSeries (Fin 1) A)) = + (MvPowerSeries.X 0 - MvPowerSeries.C f) * p.1 := rfl + rw [hcoe, sub_mul, map_sub, MvPowerSeries.X_def] + rw [MvPowerSeries.coeff_monomial_mul, MvPowerSeries.coeff_C_mul] + simp [oneExponent] + +theorem coeff_plusRelation_succ (f : A) (p : TateAlgebra A (Fin 1)) (n : ℕ) : + TateAlgebra.coeff A (Fin 1) (oneExponent (n + 1)) (plusRelation K A f p) = + TateAlgebra.coeff A (Fin 1) (oneExponent n) p - + f * TateAlgebra.coeff A (Fin 1) (oneExponent (n + 1)) p := by + change MvPowerSeries.coeff (oneExponent (n + 1)) + (((tateVariable A (Fin 1) 0 - TateAlgebra.C A (Fin 1) f) * p : + TateAlgebra A (Fin 1)) : MvPowerSeries (Fin 1) A) = _ + have hcoe : + ((((tateVariable A (Fin 1) 0 - TateAlgebra.C A (Fin 1) f) * p : + TateAlgebra A (Fin 1)) : MvPowerSeries (Fin 1) A)) = + (MvPowerSeries.X 0 - MvPowerSeries.C f) * p.1 := rfl + rw [hcoe, sub_mul, map_sub, MvPowerSeries.X_def] + rw [MvPowerSeries.coeff_monomial_mul, MvPowerSeries.coeff_C_mul] + simp [oneExponent] + +theorem coeff_minusRelation_zero (f : A) (q : TateAlgebra A (Fin 1)) : + TateAlgebra.coeff A (Fin 1) (oneExponent 0) (minusRelation K A f q) = + TateAlgebra.coeff A (Fin 1) (oneExponent 0) q := by + change MvPowerSeries.coeff (oneExponent 0) + (((1 - TateAlgebra.C A (Fin 1) f * tateVariable A (Fin 1) 0) * q : + TateAlgebra A (Fin 1)) : MvPowerSeries (Fin 1) A) = _ + have hcoe : + ((((1 - TateAlgebra.C A (Fin 1) f * tateVariable A (Fin 1) 0) * q : + TateAlgebra A (Fin 1)) : MvPowerSeries (Fin 1) A)) = + (1 - MvPowerSeries.C f * MvPowerSeries.X 0) * q.1 := rfl + rw [hcoe, sub_mul, one_mul, map_sub] + rw [show MvPowerSeries.C f * MvPowerSeries.X 0 * q.1 = + MvPowerSeries.C f * (MvPowerSeries.X 0 * q.1) by ring] + rw [MvPowerSeries.coeff_C_mul, MvPowerSeries.X_def, + MvPowerSeries.coeff_monomial_mul] + simp [oneExponent] + +theorem coeff_minusRelation_succ (f : A) (q : TateAlgebra A (Fin 1)) (n : ℕ) : + TateAlgebra.coeff A (Fin 1) (oneExponent (n + 1)) (minusRelation K A f q) = + TateAlgebra.coeff A (Fin 1) (oneExponent (n + 1)) q - + f * TateAlgebra.coeff A (Fin 1) (oneExponent n) q := by + change MvPowerSeries.coeff (oneExponent (n + 1)) + (((1 - TateAlgebra.C A (Fin 1) f * tateVariable A (Fin 1) 0) * q : + TateAlgebra A (Fin 1)) : MvPowerSeries (Fin 1) A) = _ + have hcoe : + ((((1 - TateAlgebra.C A (Fin 1) f * tateVariable A (Fin 1) 0) * q : + TateAlgebra A (Fin 1)) : MvPowerSeries (Fin 1) A)) = + (1 - MvPowerSeries.C f * MvPowerSeries.X 0) * q.1 := rfl + rw [hcoe, sub_mul, one_mul, map_sub] + rw [show MvPowerSeries.C f * MvPowerSeries.X 0 * q.1 = + MvPowerSeries.C f * (MvPowerSeries.X 0 * q.1) by ring] + rw [MvPowerSeries.coeff_C_mul, MvPowerSeries.X_def, + MvPowerSeries.coeff_monomial_mul] + simp [oneExponent] + +/-- The chart relation square in BGR 8.2.3 commutes. -/ +theorem difference_comp_chartRelations (f : A) : + (difference K A).comp (chartRelations K A f) = + (relation K A f).comp (relationFactor K A) := by + apply LinearMap.ext + rintro ⟨p, q⟩ + ext z + simp only [LinearMap.comp_apply, chartRelations_apply] + rcases lt_trichotomy z 0 with hzneg | rfl | hzpos + · obtain ⟨n, rfl⟩ := Int.eq_negSucc_of_lt_zero hzneg + have hdiff := difference_coeff_neg K A + (plusRelation K A f p) (minusRelation K A f q) (n + 1) (Nat.succ_pos n) + have hindex : -((n + 1 : ℕ) : ℤ) = Int.negSucc n := by omega + rw [hindex] at hdiff + rw [hdiff, coeff_minusRelation_succ] + rw [relation_apply] + have hsub : Int.negSucc n - 1 = Int.negSucc (n + 1) := by omega + rw [hsub, relationFactor_apply_negSucc, relationFactor_apply_negSucc] + ring + · rw [difference_coeff_zero, coeff_plusRelation_zero, coeff_minusRelation_zero, + relation_apply] + have hsub : (0 : ℤ) - 1 = Int.negSucc 0 := by omega + rw [hsub, relationFactor_apply_negSucc] + have hzero := relationFactor_apply_ofNat K A p q 0 + change (relationFactor K A (p, q)).1 0 = + TateAlgebra.coeff A (Fin 1) (oneExponent 0) p at hzero + rw [hzero] + ring + · obtain ⟨n, rfl⟩ := Int.eq_succ_of_zero_lt hzpos + have hdiff := difference_coeff_pos K A + (plusRelation K A f p) (minusRelation K A f q) (n + 1) (Nat.succ_pos n) + have hindex : ((n + 1 : ℕ) : ℤ) = (n : ℤ) + 1 := by omega + rw [hindex] at hdiff + rw [hdiff, coeff_plusRelation_succ] + rw [relation_apply] + have hsub : ((n + 1 : ℕ) : ℤ) - 1 = (n : ℤ) := by omega + rw [show (n : ℤ) + 1 = ((n + 1 : ℕ) : ℤ) by omega] + rw [hsub, relationFactor_apply_ofNat, relationFactor_apply_ofNat] + +/-- The two chart relation submodules map onto exactly the Laurent relation submodule. This is +the exact relation-row statement needed before descending the completed Laurent sequence to the +three analytic chart quotients. -/ +theorem map_range_chartRelations (f : A) : + Submodule.map (difference K A) (LinearMap.range (chartRelations K A f)) = + LinearMap.range (relation K A f) := by + ext x + constructor + · rintro ⟨y, ⟨z, rfl⟩, rfl⟩ + refine ⟨relationFactor K A z, ?_⟩ + have h := congrArg (fun L : + TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1) →ₗ[K] Series K A ↦ L z) + (difference_comp_chartRelations K A f) + simpa only [LinearMap.comp_apply] using h.symm + · rintro ⟨c, rfl⟩ + obtain ⟨z, rfl⟩ := relationFactor_surjective K A c + refine ⟨chartRelations K A f z, ⟨z, rfl⟩, ?_⟩ + have h := congrArg (fun L : + TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1) →ₗ[K] Series K A ↦ L z) + (difference_comp_chartRelations K A f) + simpa only [LinearMap.comp_apply] using h + +/-- The quotient of the two chart Tate algebras by the two relation submodules. -/ +abbrev ChartRelationQuotient (f : A) := + (TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1)) ⧸ + LinearMap.range (chartRelations K A f) + +/-- Restricted Laurent coefficients modulo multiplication by `ζ - f`. -/ +abbrev LaurentRelationQuotient (f : A) := + Series K A ⧸ LinearMap.range (relation K A f) + +/-- The diagonal map after quotienting the two chart relation submodules. The source is written +as the quotient by the zero submodule so that the general quotient-exactness lemma applies +directly. -/ +noncomputable def quotientDiagonal (f : A) : + (A ⧸ (⊥ : Submodule K A)) →ₗ[K] ChartRelationQuotient K A f := + (⊥ : Submodule K A).mapQ (LinearMap.range (chartRelations K A f)) + (diagonal K A) bot_le + +private theorem chartRelations_le_comap_difference (f : A) : + LinearMap.range (chartRelations K A f) ≤ + Submodule.comap (difference K A) (LinearMap.range (relation K A f)) := by + rw [← Submodule.map_le_iff_le_comap, map_range_chartRelations] + +/-- Laurent difference after quotienting the chart and Laurent relation submodules. -/ +noncomputable def quotientDifference (f : A) : + ChartRelationQuotient K A f →ₗ[K] LaurentRelationQuotient K A f := + (LinearMap.range (chartRelations K A f)).mapQ + (LinearMap.range (relation K A f)) (difference K A) + (chartRelations_le_comap_difference K A f) + +/-- Exactness of the completed Laurent row descends through the relation submodules. -/ +theorem quotient_exact (f : A) : + Function.Exact (quotientDiagonal K A f) (quotientDifference K A f) := by + apply (Function.Exact.exact_mapQ_iff (exact K A) + bot_le (chartRelations_le_comap_difference K A f)).2 + rw [map_range_chartRelations] + exact inf_le_right + +/-- The descended Laurent difference remains surjective. -/ +theorem quotientDifference_surjective (f : A) : + Function.Surjective (quotientDifference K A f) := by + intro z + obtain ⟨c, rfl⟩ := + (LinearMap.range (relation K A f)).mkQ_surjective z + obtain ⟨pq, rfl⟩ := difference_surjective K A c + refine ⟨Submodule.Quotient.mk pq, ?_⟩ + rfl + +end CompletedLaurent + +end Rigid diff --git a/Rigid/AffinoidAlgebra/CompletedLaurentTwoVariable.lean b/Rigid/AffinoidAlgebra/CompletedLaurentTwoVariable.lean new file mode 100644 index 0000000..fd38aa0 --- /dev/null +++ b/Rigid/AffinoidAlgebra/CompletedLaurentTwoVariable.lean @@ -0,0 +1,781 @@ +import Rigid.AffinoidAlgebra.CompletedLaurent +import Rigid.TateAlgebra.GaussNorm +import Mathlib.Topology.Algebra.InfiniteSum.Module +import Mathlib.Topology.Algebra.InfiniteSum.Nonarchimedean + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# Two-variable Tate series and restricted Laurent coefficients + +The normal form for the quotient `A⟨T,S⟩ / (TS - 1)` is a restricted Laurent family. This file +starts the analytic coefficient calculation by summing a two-variable Tate series along the +diagonals `i - j = z`. The resulting Laurent coefficients again tend to zero. +-/ + +open Filter +open scoped Topology + +universe u v + +namespace Rigid + +namespace CompletedLaurent + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +/-- The exponent `(i,j)` in a two-variable Tate algebra. -/ +noncomputable def twoExponent (i j : ℕ) : Fin 2 →₀ ℕ := + Finsupp.single 0 i + Finsupp.single 1 j + +@[simp] +theorem twoExponent_apply_zero (i j : ℕ) : twoExponent i j 0 = i := by + simp [twoExponent] + +@[simp] +theorem twoExponent_apply_one (i j : ℕ) : twoExponent i j 1 = j := by + simp [twoExponent] + +private theorem twoExponent_injective_left (j : ℕ) : + Function.Injective (fun i ↦ twoExponent i j) := by + intro i i' h + simpa using congrArg (fun e : Fin 2 →₀ ℕ ↦ e 0) h + +private theorem twoExponent_injective_right (i : ℕ) : + Function.Injective (fun j ↦ twoExponent i j) := by + intro j j' h + simpa using congrArg (fun e : Fin 2 →₀ ℕ ↦ e 1) h + +private theorem twoExponent_diagonal_injective (d : ℕ) : + Function.Injective (fun n ↦ twoExponent (d + n) n) := by + intro n n' h + simpa using congrArg (fun e : Fin 2 →₀ ℕ ↦ e 1) h + +private theorem twoExponent_antidiagonal_injective (d : ℕ) : + Function.Injective (fun n ↦ twoExponent n (d + n)) := by + intro n n' h + simpa using congrArg (fun e : Fin 2 →₀ ℕ ↦ e 0) h + +private theorem tendsto_twoVariable_coeff + (p : TateAlgebra A (Fin 2)) : + Tendsto (fun e ↦ TateAlgebra.coeff A (Fin 2) e p) cofinite (𝓝 0) := by + apply tendsto_zero_iff_norm_tendsto_zero.mpr + exact tendsto_norm_coeff_zero A (Fin 2) p + +private theorem coeff_smul_ground + (c : K) (p : TateAlgebra A (Fin 2)) (e : Fin 2 →₀ ℕ) : + TateAlgebra.coeff A (Fin 2) e (c • p) = + c • TateAlgebra.coeff A (Fin 2) e p := by + change MvPowerSeries.coeff e + ((c • p : TateAlgebra A (Fin 2)) : MvPowerSeries (Fin 2) A) = + c • MvPowerSeries.coeff e p.1 + have hcoe : + ((c • p : TateAlgebra A (Fin 2)) : MvPowerSeries (Fin 2) A) = + MvPowerSeries.C (algebraMap K A c) * p.1 := by + rw [Algebra.smul_def] + rfl + rw [hcoe, MvPowerSeries.coeff_C_mul, Algebra.smul_def] + +theorem positiveDiagonal_summable + (p : TateAlgebra A (Fin 2)) (d : ℕ) : + Summable (fun n ↦ TateAlgebra.coeff A (Fin 2) (twoExponent (d + n) n) p) := by + rw [NonarchimedeanAddGroup.summable_iff_tendsto_cofinite_zero] + exact (tendsto_twoVariable_coeff A p).comp + (twoExponent_diagonal_injective d).tendsto_cofinite + +theorem negativeDiagonal_summable + (p : TateAlgebra A (Fin 2)) (d : ℕ) : + Summable (fun n ↦ TateAlgebra.coeff A (Fin 2) (twoExponent n (d + n)) p) := by + rw [NonarchimedeanAddGroup.summable_iff_tendsto_cofinite_zero] + exact (tendsto_twoVariable_coeff A p).comp + (twoExponent_antidiagonal_injective d).tendsto_cofinite + +/-- Sum the coefficients of a two-variable Tate series along the diagonal `i - j = z`. -/ +noncomputable def diagonalCoefficient (p : TateAlgebra A (Fin 2)) (z : ℤ) : A := + if _hz : 0 ≤ z then + ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) (twoExponent (z.toNat + n) n) p + else + ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) (twoExponent n ((-z).toNat + n)) p + +theorem diagonalCoefficient_of_nonneg + (p : TateAlgebra A (Fin 2)) (z : ℤ) (hz : 0 ≤ z) : + diagonalCoefficient A p z = + ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) (twoExponent (z.toNat + n) n) p := by + simp [diagonalCoefficient, hz] + +theorem diagonalCoefficient_of_neg + (p : TateAlgebra A (Fin 2)) (z : ℤ) (hz : z < 0) : + diagonalCoefficient A p z = + ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) (twoExponent n ((-z).toNat + n)) p := by + simp [diagonalCoefficient, not_le_of_gt hz] + +private def exponentDegree (e : Fin 2 →₀ ℕ) : ℤ := + (e 0 : ℤ) - (e 1 : ℤ) + +private theorem exponentDegree_positiveDiagonal + (z : ℤ) (hz : 0 ≤ z) (n : ℕ) : + exponentDegree (twoExponent (z.toNat + n) n) = z := by + simp only [exponentDegree, twoExponent_apply_zero, twoExponent_apply_one] + push_cast + rw [Int.toNat_of_nonneg hz] + omega + +private theorem exponentDegree_negativeDiagonal + (z : ℤ) (hz : z < 0) (n : ℕ) : + exponentDegree (twoExponent n ((-z).toNat + n)) = z := by + simp only [exponentDegree, twoExponent_apply_zero, twoExponent_apply_one] + push_cast + rw [Int.toNat_of_nonneg (Int.neg_nonneg.mpr hz.le)] + omega + +private theorem tendsto_diagonalCoefficient + (p : TateAlgebra A (Fin 2)) : + Tendsto (diagonalCoefficient A p) cofinite (𝓝 0) := by + apply tendsto_zero_iff_norm_tendsto_zero.mpr + apply Metric.tendsto_nhds.mpr + intro ε hε + have hhalf : 0 < ε / 2 := half_pos hε + have heventually : + ∀ᶠ e : Fin 2 →₀ ℕ in cofinite, + ‖TateAlgebra.coeff A (Fin 2) e p‖ < ε / 2 := by + have hnorm : + Tendsto (fun e ↦ ‖TateAlgebra.coeff A (Fin 2) e p‖) cofinite (𝓝 0) := + tendsto_norm_coeff_zero A (Fin 2) p + simpa [Real.dist_eq] using Metric.tendsto_nhds.mp hnorm (ε / 2) hhalf + let bad : Set (Fin 2 →₀ ℕ) := + {e | ε / 2 ≤ ‖TateAlgebra.coeff A (Fin 2) e p‖} + have hbad : bad.Finite := by + have hcompl : badᶜ ∈ (cofinite : Filter (Fin 2 →₀ ℕ)) := by + simpa [bad, Set.compl_setOf, not_le] using heventually + simpa using mem_cofinite.mp hcompl + let badDegrees : Set ℤ := exponentDegree '' bad + have hbadDegrees : badDegrees.Finite := hbad.image exponentDegree + filter_upwards [hbadDegrees.compl_mem_cofinite] with z hz + rw [dist_zero_right] + simp only [Real.norm_eq_abs, abs_of_nonneg (norm_nonneg _)] + by_cases hz0 : 0 ≤ z + · rw [diagonalCoefficient_of_nonneg A p z hz0] + refine (IsUltrametricDist.norm_tsum_le_of_forall_le_of_nonneg + (f := fun n : ℕ ↦ TateAlgebra.coeff A (Fin 2) + (twoExponent (z.toNat + n) n) p) hhalf.le fun n ↦ ?_).trans_lt + (half_lt_self hε) + apply le_of_lt + by_contra hn + have hmemBad : + twoExponent (z.toNat + n) n ∈ bad := by + change ε / 2 ≤ ‖TateAlgebra.coeff A (Fin 2) (twoExponent (z.toNat + n) n) p‖ + exact le_of_not_gt hn + exact hz ⟨twoExponent (z.toNat + n) n, hmemBad, + exponentDegree_positiveDiagonal z hz0 n⟩ + · have hzneg : z < 0 := lt_of_not_ge hz0 + rw [diagonalCoefficient_of_neg A p z hzneg] + refine (IsUltrametricDist.norm_tsum_le_of_forall_le_of_nonneg + (f := fun n : ℕ ↦ TateAlgebra.coeff A (Fin 2) + (twoExponent n ((-z).toNat + n)) p) hhalf.le fun n ↦ ?_).trans_lt + (half_lt_self hε) + apply le_of_lt + by_contra hn + have hmemBad : + twoExponent n ((-z).toNat + n) ∈ bad := by + change ε / 2 ≤ + ‖TateAlgebra.coeff A (Fin 2) (twoExponent n ((-z).toNat + n)) p‖ + exact le_of_not_gt hn + exact hz ⟨twoExponent n ((-z).toNat + n), hmemBad, + exponentDegree_negativeDiagonal z hzneg n⟩ + +/-- Diagonal summation from two-variable Tate series to restricted Laurent coefficients. -/ +noncomputable def twoVariableNormal : + TateAlgebra A (Fin 2) →ₗ[K] Series K A where + toFun p := ⟨diagonalCoefficient A p, tendsto_diagonalCoefficient A p⟩ + map_add' p q := by + ext z + change diagonalCoefficient A (p + q) z = + diagonalCoefficient A p z + diagonalCoefficient A q z + by_cases hz : 0 ≤ z + · rw [diagonalCoefficient_of_nonneg A (p + q) z hz, + diagonalCoefficient_of_nonneg A p z hz, + diagonalCoefficient_of_nonneg A q z hz] + change + (∑' n : ℕ, (p.1 (twoExponent (z.toNat + n) n) + + q.1 (twoExponent (z.toNat + n) n))) = + (∑' n : ℕ, p.1 (twoExponent (z.toNat + n) n)) + + ∑' n : ℕ, q.1 (twoExponent (z.toNat + n) n) + exact + (positiveDiagonal_summable A p z.toNat).tsum_add + (positiveDiagonal_summable A q z.toNat) + · have hzneg : z < 0 := lt_of_not_ge hz + rw [diagonalCoefficient_of_neg A (p + q) z hzneg, + diagonalCoefficient_of_neg A p z hzneg, + diagonalCoefficient_of_neg A q z hzneg] + change + (∑' n : ℕ, (p.1 (twoExponent n ((-z).toNat + n)) + + q.1 (twoExponent n ((-z).toNat + n)))) = + (∑' n : ℕ, p.1 (twoExponent n ((-z).toNat + n))) + + ∑' n : ℕ, q.1 (twoExponent n ((-z).toNat + n)) + exact + (negativeDiagonal_summable A p (-z).toNat).tsum_add + (negativeDiagonal_summable A q (-z).toNat) + map_smul' c p := by + ext z + change diagonalCoefficient A (c • p) z = c • diagonalCoefficient A p z + by_cases hz : 0 ≤ z + · rw [diagonalCoefficient_of_nonneg A (c • p) z hz, + diagonalCoefficient_of_nonneg A p z hz] + simp_rw [coeff_smul_ground K A] + exact + (tsum_const_smul'' c : + (∑' n : ℕ, c • TateAlgebra.coeff A (Fin 2) + (twoExponent (z.toNat + n) n) p) = + c • ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) + (twoExponent (z.toNat + n) n) p) + · have hzneg : z < 0 := lt_of_not_ge hz + rw [diagonalCoefficient_of_neg A (c • p) z hzneg, + diagonalCoefficient_of_neg A p z hzneg] + simp_rw [coeff_smul_ground K A] + exact + (tsum_const_smul'' c : + (∑' n : ℕ, c • TateAlgebra.coeff A (Fin 2) + (twoExponent n ((-z).toNat + n)) p) = + c • ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) + (twoExponent n ((-z).toNat + n)) p) + +@[simp] +theorem twoVariableNormal_apply + (p : TateAlgebra A (Fin 2)) (z : ℤ) : + (twoVariableNormal K A p).1 z = diagonalCoefficient A p z := + rfl + +private def axisCoefficient (c : Series K A) (e : Fin 2 →₀ ℕ) : A := + if e 0 = 0 ∨ e 1 = 0 then c.1 (exponentDegree e) else 0 + +private theorem exponentDegree_injectiveOn_axes : + Set.InjOn exponentDegree {e : Fin 2 →₀ ℕ | e 0 = 0 ∨ e 1 = 0} := by + intro e he e' he' hdegree + apply Finsupp.ext + intro i + fin_cases i + · rcases he with he0 | he1 <;> rcases he' with he0' | he1' + · simp [he0, he0'] + · have hcast : + (e 0 : ℤ) - (e 1 : ℤ) = (e' 0 : ℤ) - (e' 1 : ℤ) := hdegree + rw [he0, he1'] at hcast + simp only [Nat.cast_zero, zero_sub, sub_zero] at hcast + have he0'zero : e' 0 = 0 := by omega + simp [he0, he0'zero] + · have hcast : + (e 0 : ℤ) - (e 1 : ℤ) = (e' 0 : ℤ) - (e' 1 : ℤ) := hdegree + rw [he1, he0'] at hcast + simp only [Nat.cast_zero, sub_zero, zero_sub] at hcast + have he0zero : e 0 = 0 := by omega + simp [he0zero, he0'] + · have hcast : + (e 0 : ℤ) - (e 1 : ℤ) = (e' 0 : ℤ) - (e' 1 : ℤ) := hdegree + rw [he1, he1'] at hcast + simp only [Nat.cast_zero, sub_zero] at hcast + exact_mod_cast hcast + · rcases he with he0 | he1 <;> rcases he' with he0' | he1' + · have hcast : + (e 0 : ℤ) - (e 1 : ℤ) = (e' 0 : ℤ) - (e' 1 : ℤ) := hdegree + rw [he0, he0'] at hcast + simp only [Nat.cast_zero, zero_sub] at hcast + exact_mod_cast neg_injective hcast + · have hcast : + (e 0 : ℤ) - (e 1 : ℤ) = (e' 0 : ℤ) - (e' 1 : ℤ) := hdegree + rw [he0, he1'] at hcast + simp only [Nat.cast_zero, zero_sub, sub_zero] at hcast + have : e 1 = 0 := by omega + simp [this, he1'] + · have hcast : + (e 0 : ℤ) - (e 1 : ℤ) = (e' 0 : ℤ) - (e' 1 : ℤ) := hdegree + rw [he1, he0'] at hcast + simp only [Nat.cast_zero, sub_zero, zero_sub] at hcast + have : e' 1 = 0 := by omega + simp [he1, this] + · simp [he1, he1'] + +private theorem tendsto_axisCoefficient + (c : Series K A) : + Tendsto (axisCoefficient K A c) cofinite (𝓝 0) := by + rw [tendsto_def] + intro s hs + have hzero : (0 : A) ∈ s := mem_of_mem_nhds hs + have hc : {z | c.1 z ∈ s} ∈ (cofinite : Filter ℤ) := c.2 hs + rw [mem_cofinite] at hc ⊢ + have hbadDegree : Set.Finite {z : ℤ | c.1 z ∉ s} := by + simpa only [Set.compl_setOf] using hc + let bad : Set (Fin 2 →₀ ℕ) := {e | axisCoefficient K A c e ∉ s} + change bad.Finite + apply Set.Finite.of_finite_image + · exact hbadDegree.subset fun z hz ↦ by + obtain ⟨e, he, rfl⟩ := hz + change axisCoefficient K A c e ∉ s at he + by_cases haxis : e 0 = 0 ∨ e 1 = 0 + · simpa [axisCoefficient, haxis] using he + · exact (he (by simpa [axisCoefficient, haxis] using hzero)).elim + · intro e he e' he' hdegree + apply exponentDegree_injectiveOn_axes + · by_contra haxis + change axisCoefficient K A c e ∉ s at he + have haxis' : ¬(e 0 = 0 ∨ e 1 = 0) := by simpa using haxis + apply he + rw [axisCoefficient, if_neg haxis'] + exact hzero + · by_contra haxis + change axisCoefficient K A c e' ∉ s at he' + have haxis' : ¬(e' 0 = 0 ∨ e' 1 = 0) := by simpa using haxis + apply he' + rw [axisCoefficient, if_neg haxis'] + exact hzero + · exact hdegree + +/-- Put a restricted Laurent family on the two coordinate axes in `A⟨T,S⟩`. -/ +noncomputable def axisSeries (c : Series K A) : TateAlgebra A (Fin 2) := + ⟨axisCoefficient K A c, by + change Tendsto (fun e : Fin 2 →₀ ℕ ↦ + ‖axisCoefficient K A c e‖ * e.prod fun _ n ↦ (1 : ℝ) ^ n) cofinite (𝓝 0) + simp only [one_pow, Finsupp.prod, Finset.prod_const_one, mul_one] + exact tendsto_zero_iff_norm_tendsto_zero.mp (tendsto_axisCoefficient K A c)⟩ + +@[simp] +theorem coeff_axisSeries (c : Series K A) (e : Fin 2 →₀ ℕ) : + TateAlgebra.coeff A (Fin 2) e (axisSeries K A c) = axisCoefficient K A c e := + rfl + +theorem coeff_axisSeries_twoExponent (c : Series K A) (i j : ℕ) : + TateAlgebra.coeff A (Fin 2) (twoExponent i j) (axisSeries K A c) = + if i = 0 ∨ j = 0 then c.1 ((i : ℤ) - (j : ℤ)) else 0 := by + change axisCoefficient K A c (twoExponent i j) = + if i = 0 ∨ j = 0 then c.1 ((i : ℤ) - (j : ℤ)) else 0 + simp [axisCoefficient, exponentDegree] + +private theorem axisCoefficient_positive_zero + (c : Series K A) (z : ℤ) (hz : 0 ≤ z) : + axisCoefficient K A c (twoExponent z.toNat 0) = c.1 z := by + rw [axisCoefficient, if_pos (Or.inr (twoExponent_apply_one z.toNat 0))] + rw [show exponentDegree (twoExponent z.toNat 0) = z by + simpa using exponentDegree_positiveDiagonal z hz 0] + +private theorem axisCoefficient_positive_succ + (c : Series K A) (z : ℤ) (_hz : 0 ≤ z) (n : ℕ) : + axisCoefficient K A c (twoExponent (z.toNat + (n + 1)) (n + 1)) = 0 := by + rw [axisCoefficient, if_neg] + simp only [twoExponent_apply_zero, twoExponent_apply_one] + omega + +private theorem axisCoefficient_negative_zero + (c : Series K A) (z : ℤ) (hz : z < 0) : + axisCoefficient K A c (twoExponent 0 (-z).toNat) = c.1 z := by + rw [axisCoefficient, if_pos (Or.inl (twoExponent_apply_zero 0 (-z).toNat))] + rw [show exponentDegree (twoExponent 0 (-z).toNat) = z by + simpa using exponentDegree_negativeDiagonal z hz 0] + +private theorem axisCoefficient_negative_succ + (c : Series K A) (z : ℤ) (_hz : z < 0) (n : ℕ) : + axisCoefficient K A c (twoExponent (n + 1) ((-z).toNat + (n + 1))) = 0 := by + rw [axisCoefficient, if_neg] + simp only [twoExponent_apply_zero, twoExponent_apply_one] + omega + +/-- Diagonal normal form sends the axis representative back to its Laurent family. -/ +theorem twoVariableNormal_axisSeries (c : Series K A) : + twoVariableNormal K A (axisSeries K A c) = c := by + apply Subtype.ext + funext z + rw [twoVariableNormal_apply] + by_cases hz : 0 ≤ z + · rw [diagonalCoefficient_of_nonneg A _ z hz] + rw [tsum_eq_single 0] + · exact axisCoefficient_positive_zero K A c z hz + · intro n hn + obtain ⟨m, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hn + exact axisCoefficient_positive_succ K A c z hz m + · have hzneg : z < 0 := lt_of_not_ge hz + rw [diagonalCoefficient_of_neg A _ z hzneg] + rw [tsum_eq_single 0] + · exact axisCoefficient_negative_zero K A c z hzneg + · intro n hn + obtain ⟨m, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hn + exact axisCoefficient_negative_succ K A c z hzneg m + +/-- Diagonal normal form is onto. -/ +theorem twoVariableNormal_surjective : + Function.Surjective (twoVariableNormal K A) := + fun c ↦ ⟨axisSeries K A c, twoVariableNormal_axisSeries K A c⟩ + +private noncomputable def tailExponent (e : Fin 2 →₀ ℕ) (n : ℕ) : Fin 2 →₀ ℕ := + e + twoExponent (n + 1) (n + 1) + +private theorem tailExponent_injective (e : Fin 2 →₀ ℕ) : + Function.Injective (tailExponent e) := by + intro n n' h + have hzero := congrArg (fun d : Fin 2 →₀ ℕ ↦ d 0) h + simpa [tailExponent] using hzero + +private theorem tail_summable + (p : TateAlgebra A (Fin 2)) (e : Fin 2 →₀ ℕ) : + Summable (fun n ↦ TateAlgebra.coeff A (Fin 2) (tailExponent e n) p) := by + rw [NonarchimedeanAddGroup.summable_iff_tendsto_cofinite_zero] + exact (tendsto_twoVariable_coeff A p).comp + (tailExponent_injective e).tendsto_cofinite + +/-- The sum of the coefficients strictly farther along the diagonal through `e`. -/ +noncomputable def tailCoefficient + (p : TateAlgebra A (Fin 2)) (e : Fin 2 →₀ ℕ) : A := + ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) (tailExponent e n) p + +private theorem le_tailExponent (e : Fin 2 →₀ ℕ) (n : ℕ) : + e ≤ tailExponent e n := by + intro i + simp only [tailExponent, Finsupp.add_apply] + omega + +private theorem tendsto_tailCoefficient + (p : TateAlgebra A (Fin 2)) : + Tendsto (tailCoefficient A p) cofinite (𝓝 0) := by + apply tendsto_zero_iff_norm_tendsto_zero.mpr + apply Metric.tendsto_nhds.mpr + intro ε hε + have hhalf : 0 < ε / 2 := half_pos hε + have heventually : + ∀ᶠ e : Fin 2 →₀ ℕ in cofinite, + ‖TateAlgebra.coeff A (Fin 2) e p‖ < ε / 2 := by + have hnorm : + Tendsto (fun e ↦ ‖TateAlgebra.coeff A (Fin 2) e p‖) cofinite (𝓝 0) := + tendsto_norm_coeff_zero A (Fin 2) p + simpa [Real.dist_eq] using Metric.tendsto_nhds.mp hnorm (ε / 2) hhalf + let bad : Set (Fin 2 →₀ ℕ) := + {e | ε / 2 ≤ ‖TateAlgebra.coeff A (Fin 2) e p‖} + have hbad : bad.Finite := by + have hcompl : badᶜ ∈ (cofinite : Filter (Fin 2 →₀ ℕ)) := by + simpa [bad, Set.compl_setOf, not_le] using heventually + simpa using mem_cofinite.mp hcompl + let badLower : Set (Fin 2 →₀ ℕ) := ⋃ b ∈ bad, Set.Iic b + have hbadLower : badLower.Finite := by + obtain ⟨bound, hbound⟩ := + Set.exists_upper_bound_image bad Finsupp.degree hbad + apply (Finsupp.finite_of_degree_le bound.degree).subset + intro e he + obtain ⟨b, hb, heb⟩ := Set.mem_iUnion₂.mp he + exact (Finsupp.degree_mono heb).trans (hbound b hb) + filter_upwards [hbadLower.compl_mem_cofinite] with e he + rw [dist_zero_right] + simp only [Real.norm_eq_abs, abs_of_nonneg (norm_nonneg _)] + refine (IsUltrametricDist.norm_tsum_le_of_forall_le_of_nonneg + (f := fun n : ℕ ↦ TateAlgebra.coeff A (Fin 2) (tailExponent e n) p) + hhalf.le fun n ↦ ?_).trans_lt (half_lt_self hε) + apply le_of_lt + by_contra hn + have htailBad : tailExponent e n ∈ bad := by + change ε / 2 ≤ ‖TateAlgebra.coeff A (Fin 2) (tailExponent e n) p‖ + exact le_of_not_gt hn + apply he + exact Set.mem_iUnion₂.mpr + ⟨tailExponent e n, htailBad, le_tailExponent e n⟩ + +/-- The diagonal-tail series used to divide by `TS - 1`. -/ +noncomputable def tailSeries (p : TateAlgebra A (Fin 2)) : TateAlgebra A (Fin 2) := + ⟨tailCoefficient A p, by + change Tendsto (fun e : Fin 2 →₀ ℕ ↦ + ‖tailCoefficient A p e‖ * e.prod fun _ n ↦ (1 : ℝ) ^ n) cofinite (𝓝 0) + simp only [one_pow, Finsupp.prod, Finset.prod_const_one, mul_one] + exact tendsto_zero_iff_norm_tendsto_zero.mp (tendsto_tailCoefficient A p)⟩ + +@[simp] +theorem coeff_tailSeries (p : TateAlgebra A (Fin 2)) (e : Fin 2 →₀ ℕ) : + TateAlgebra.coeff A (Fin 2) e (tailSeries A p) = tailCoefficient A p e := + rfl + +private theorem coe_twoVariableProduct : + ((tateVariable A (Fin 2) 0 * tateVariable A (Fin 2) 1 : + TateAlgebra A (Fin 2)) : MvPowerSeries (Fin 2) A) = + MvPowerSeries.monomial (twoExponent 1 1) 1 := by + change MvPowerSeries.X 0 * MvPowerSeries.X 1 = + MvPowerSeries.monomial (twoExponent 1 1) 1 + rw [MvPowerSeries.X_def, MvPowerSeries.X_def, + MvPowerSeries.monomial_mul_monomial] + simp [twoExponent] + +/-- Multiplication by `TS - 1` in the two-variable Tate algebra. -/ +noncomputable def unitRelation : + TateAlgebra A (Fin 2) →ₗ[K] TateAlgebra A (Fin 2) where + toFun p := + (tateVariable A (Fin 2) 0 * tateVariable A (Fin 2) 1 - 1) * p + map_add' p q := by rw [mul_add] + map_smul' c p := by rw [RingHom.id_apply, mul_smul_comm] + +/-- Coefficients of multiplication by `TS - 1`. -/ +theorem coeff_unitRelation (p : TateAlgebra A (Fin 2)) (e : Fin 2 →₀ ℕ) : + TateAlgebra.coeff A (Fin 2) e (unitRelation K A p) = + (if twoExponent 1 1 ≤ e then + TateAlgebra.coeff A (Fin 2) (e - twoExponent 1 1) p else 0) - + TateAlgebra.coeff A (Fin 2) e p := by + change MvPowerSeries.coeff e + ((((tateVariable A (Fin 2) 0 * tateVariable A (Fin 2) 1 - 1) * p : + TateAlgebra A (Fin 2))) : MvPowerSeries (Fin 2) A) = _ + have hcoe : + ((((tateVariable A (Fin 2) 0 * tateVariable A (Fin 2) 1 - 1) * p : + TateAlgebra A (Fin 2))) : MvPowerSeries (Fin 2) A) = + (MvPowerSeries.monomial (twoExponent 1 1) 1 - 1) * p.1 := by + change + (((tateVariable A (Fin 2) 0 * tateVariable A (Fin 2) 1 : + TateAlgebra A (Fin 2)) : MvPowerSeries (Fin 2) A) - 1) * p.1 = + (MvPowerSeries.monomial (twoExponent 1 1) 1 - 1) * p.1 + rw [coe_twoVariableProduct] + rw [hcoe, sub_mul, map_sub, MvPowerSeries.coeff_monomial_mul, one_mul, one_mul] + rfl + +private theorem twoExponent_one_le_iff (i j : ℕ) : + twoExponent 1 1 ≤ twoExponent i j ↔ 0 < i ∧ 0 < j := by + constructor + · intro h + constructor + · have h0 := h 0 + have h0' : 1 ≤ i := by + simpa only [twoExponent_apply_zero] using h0 + omega + · have h1 := h 1 + have h1' : 1 ≤ j := by + simpa only [twoExponent_apply_one] using h1 + omega + · rintro ⟨hi, hj⟩ k + fin_cases k + · simpa [twoExponent] using (Nat.succ_le_iff.mpr hi) + · simpa [twoExponent] using (Nat.succ_le_iff.mpr hj) + +private theorem twoExponent_sub_one (i j : ℕ) (_hi : 0 < i) (_hj : 0 < j) : + twoExponent i j - twoExponent 1 1 = twoExponent (i - 1) (j - 1) := by + apply Finsupp.ext + intro k + fin_cases k <;> simp + +theorem coeff_unitRelation_twoExponent + (p : TateAlgebra A (Fin 2)) (i j : ℕ) : + TateAlgebra.coeff A (Fin 2) (twoExponent i j) (unitRelation K A p) = + if 0 < i ∧ 0 < j then + TateAlgebra.coeff A (Fin 2) (twoExponent (i - 1) (j - 1)) p - + TateAlgebra.coeff A (Fin 2) (twoExponent i j) p + else + -TateAlgebra.coeff A (Fin 2) (twoExponent i j) p := by + rw [coeff_unitRelation] + by_cases h : 0 < i ∧ 0 < j + · rw [if_pos h, if_pos ((twoExponent_one_le_iff i j).2 h), + twoExponent_sub_one i j h.1 h.2] + · rw [if_neg h, if_neg (by simpa [twoExponent_one_le_iff] using h)] + simp + +private theorem tailExponent_twoExponent (i j n : ℕ) : + tailExponent (twoExponent i j) n = twoExponent (i + (n + 1)) (j + (n + 1)) := by + apply Finsupp.ext + intro k + fin_cases k <;> simp [tailExponent, twoExponent] + +private theorem tailCoefficient_twoExponent + (p : TateAlgebra A (Fin 2)) (i j : ℕ) : + tailCoefficient A p (twoExponent i j) = + ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) + (twoExponent (i + (n + 1)) (j + (n + 1))) p := by + unfold tailCoefficient + congr 1 + funext n + rw [tailExponent_twoExponent] + +private theorem tailCoefficient_rec + (p : TateAlgebra A (Fin 2)) (i j : ℕ) : + tailCoefficient A p (twoExponent i j) = + TateAlgebra.coeff A (Fin 2) (twoExponent (i + 1) (j + 1)) p + + tailCoefficient A p (twoExponent (i + 1) (j + 1)) := by + unfold tailCoefficient + rw [(tail_summable A p (twoExponent i j)).tsum_eq_zero_add] + simp_rw [tailExponent_twoExponent] + congr 1 + apply tsum_congr + intro n + congr 2 <;> omega + +private theorem exponentDegree_twoExponent (i j : ℕ) : + exponentDegree (twoExponent i j) = (i : ℤ) - (j : ℤ) := by + simp only [exponentDegree, twoExponent_apply_zero, twoExponent_apply_one] + +private theorem axisCoefficient_normal_of_right_zero + (p : TateAlgebra A (Fin 2)) (i : ℕ) : + axisCoefficient K A (twoVariableNormal K A p) (twoExponent i 0) = + TateAlgebra.coeff A (Fin 2) (twoExponent i 0) p + + tailCoefficient A p (twoExponent i 0) := by + rw [axisCoefficient, if_pos (Or.inr (twoExponent_apply_one i 0))] + rw [twoVariableNormal_apply, exponentDegree_twoExponent] + simp only [Nat.cast_zero, sub_zero] + have hz : 0 ≤ (i : ℤ) - (0 : ℤ) := by omega + rw [diagonalCoefficient_of_nonneg A p _ (by omega)] + have htoNat : (i : ℤ).toNat = i := by simp + rw [htoNat, (positiveDiagonal_summable A p i).tsum_eq_zero_add, + tailCoefficient_twoExponent A p i 0] + congr 1 + apply tsum_congr + intro n + simp + +private theorem axisCoefficient_normal_of_left_zero + (p : TateAlgebra A (Fin 2)) (j : ℕ) (hj : 0 < j) : + axisCoefficient K A (twoVariableNormal K A p) (twoExponent 0 j) = + TateAlgebra.coeff A (Fin 2) (twoExponent 0 j) p + + tailCoefficient A p (twoExponent 0 j) := by + rw [axisCoefficient, if_pos (Or.inl (twoExponent_apply_zero 0 j))] + rw [twoVariableNormal_apply, exponentDegree_twoExponent] + simp only [Nat.cast_zero, zero_sub] + have hz : (0 : ℤ) - (j : ℤ) < 0 := by omega + rw [diagonalCoefficient_of_neg A p _ (by omega)] + have htoNat : (-(-(j : ℤ))).toNat = j := by + simp + rw [htoNat, (negativeDiagonal_summable A p j).tsum_eq_zero_add, + tailCoefficient_twoExponent A p 0 j] + congr 1 + apply tsum_congr + intro n + simp + +private theorem coeff_unitRelation_tailSeries_twoExponent + (p : TateAlgebra A (Fin 2)) (i j : ℕ) : + TateAlgebra.coeff A (Fin 2) (twoExponent i j) + (unitRelation K A (tailSeries A p)) = + TateAlgebra.coeff A (Fin 2) (twoExponent i j) + (p - axisSeries K A (twoVariableNormal K A p)) := by + rw [coeff_unitRelation_twoExponent] + change + (if 0 < i ∧ 0 < j then + tailCoefficient A p (twoExponent (i - 1) (j - 1)) - + tailCoefficient A p (twoExponent i j) + else -tailCoefficient A p (twoExponent i j)) = + TateAlgebra.coeff A (Fin 2) (twoExponent i j) p - + axisCoefficient K A (twoVariableNormal K A p) (twoExponent i j) + by_cases hboth : 0 < i ∧ 0 < j + · rw [if_pos hboth] + rw [axisCoefficient, if_neg (by + simp only [twoExponent_apply_zero, twoExponent_apply_one] + omega)] + simp only [sub_zero] + have hrec := tailCoefficient_rec A p (i - 1) (j - 1) + have hi : i - 1 + 1 = i := by omega + have hj : j - 1 + 1 = j := by omega + rw [hi, hj] at hrec + rw [hrec] + abel + · rw [if_neg hboth] + rcases not_and_or.mp hboth with hi | hj + · have hi0 : i = 0 := Nat.eq_zero_of_not_pos hi + subst i + by_cases hj0 : j = 0 + · subst j + rw [axisCoefficient_normal_of_right_zero K A p 0] + abel + · rw [axisCoefficient_normal_of_left_zero K A p j + (Nat.pos_of_ne_zero hj0)] + abel + · have hj0 : j = 0 := Nat.eq_zero_of_not_pos hj + rw [hj0, axisCoefficient_normal_of_right_zero K A p i] + abel + +/-- Division with remainder on the coordinate axes for `TS - 1`. -/ +theorem unitRelation_tailSeries + (p : TateAlgebra A (Fin 2)) : + unitRelation K A (tailSeries A p) = + p - axisSeries K A (twoVariableNormal K A p) := by + apply TateAlgebra.ext + intro e + have he : e = twoExponent (e 0) (e 1) := by + apply Finsupp.ext + intro k + fin_cases k <;> simp + rw [he] + exact coeff_unitRelation_tailSeries_twoExponent K A p (e 0) (e 1) + +private theorem tsum_telescopingRelation + (a : ℕ → A) (ha : Summable a) : + (∑' n : ℕ, match n with + | 0 => -a 0 + | m + 1 => a m - a (m + 1)) = 0 := by + have hshift : Summable (fun n : ℕ ↦ a (n + 1)) := + (summable_nat_add_iff 1).2 ha + have htail : Summable (fun n : ℕ ↦ a n - a (n + 1)) := + ha.sub hshift + rw [tsum_eq_zero_add' (by simpa using htail)] + rw [ha.tsum_sub hshift] + rw [ha.tsum_eq_zero_add] + simp + +/-- Diagonal normal form kills the relation `TS - 1`. -/ +theorem twoVariableNormal_unitRelation + (p : TateAlgebra A (Fin 2)) : + twoVariableNormal K A (unitRelation K A p) = 0 := by + apply Subtype.ext + funext z + change diagonalCoefficient A (unitRelation K A p) z = 0 + by_cases hz : 0 ≤ z + · rw [diagonalCoefficient_of_nonneg A _ z hz] + let a : ℕ → A := fun n ↦ TateAlgebra.coeff A (Fin 2) + (twoExponent (z.toNat + n) n) p + calc + (∑' n : ℕ, TateAlgebra.coeff A (Fin 2) + (twoExponent (z.toNat + n) n) (unitRelation K A p)) = + ∑' n : ℕ, match n with + | 0 => -a 0 + | m + 1 => a m - a (m + 1) := by + apply tsum_congr + intro n + cases n with + | zero => + simp only [Nat.add_zero] + rw [coeff_unitRelation_twoExponent K A p z.toNat 0] + simp [a] + | succ m => + rw [coeff_unitRelation_twoExponent, if_pos (by omega)] + simp only [a] + congr 2 + _ = 0 := tsum_telescopingRelation A a (positiveDiagonal_summable A p z.toNat) + · have hzneg : z < 0 := lt_of_not_ge hz + rw [diagonalCoefficient_of_neg A _ z hzneg] + let a : ℕ → A := fun n ↦ TateAlgebra.coeff A (Fin 2) + (twoExponent n ((-z).toNat + n)) p + calc + (∑' n : ℕ, TateAlgebra.coeff A (Fin 2) + (twoExponent n ((-z).toNat + n)) (unitRelation K A p)) = + ∑' n : ℕ, match n with + | 0 => -a 0 + | m + 1 => a m - a (m + 1) := by + apply tsum_congr + intro n + cases n with + | zero => + simp only [Nat.add_zero] + rw [coeff_unitRelation_twoExponent K A p 0 (-z).toNat] + simp [a] + | succ m => + rw [coeff_unitRelation_twoExponent, if_pos (by omega)] + simp only [a] + congr 2 + _ = 0 := tsum_telescopingRelation A a (negativeDiagonal_summable A p (-z).toNat) + +@[simp] +theorem axisSeries_zero : + axisSeries K A 0 = 0 := by + apply TateAlgebra.ext + intro e + change axisCoefficient K A 0 e = 0 + simp [axisCoefficient] + +/-- The kernel of diagonal normal form is exactly the range of multiplication by `TS - 1`. -/ +theorem range_unitRelation_eq_ker_twoVariableNormal : + LinearMap.range (unitRelation K A) = LinearMap.ker (twoVariableNormal K A) := by + ext p + constructor + · rintro ⟨q, rfl⟩ + exact twoVariableNormal_unitRelation K A q + · intro hp + refine ⟨tailSeries A p, ?_⟩ + rw [unitRelation_tailSeries, LinearMap.mem_ker.mp hp, axisSeries_zero, sub_zero] + +end CompletedLaurent + +end Rigid diff --git a/Rigid/AffinoidAlgebra/CompletedLaurentTwoVariableQuotient.lean b/Rigid/AffinoidAlgebra/CompletedLaurentTwoVariableQuotient.lean new file mode 100644 index 0000000..18bc5a5 --- /dev/null +++ b/Rigid/AffinoidAlgebra/CompletedLaurentTwoVariableQuotient.lean @@ -0,0 +1,50 @@ +import Rigid.AffinoidAlgebra.CompletedLaurentTwoVariable +import Mathlib.LinearAlgebra.Isomorphisms + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# The quotient by `TS - 1` + +Diagonal summation identifies the two-variable Tate algebra modulo multiplication by `TS - 1` +with restricted Laurent coefficient families. This is the analytic normal form underlying the +overlap in a Laurent cover. +-/ + +universe u v + +namespace Rigid + +namespace CompletedLaurent + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +/-- The two-variable Tate algebra modulo the relation `TS - 1`. -/ +abbrev UnitRelationQuotient := + TateAlgebra A (Fin 2) ⧸ LinearMap.range (unitRelation K A) + +/-- Diagonal summation gives the normal form of the quotient by `TS - 1`. -/ +noncomputable def unitRelationQuotientEquiv : + UnitRelationQuotient K A ≃ₗ[K] Series K A := + (Submodule.quotEquivOfEq + (LinearMap.range (unitRelation K A)) + (LinearMap.ker (twoVariableNormal K A)) + (range_unitRelation_eq_ker_twoVariableNormal K A)).trans + ((twoVariableNormal K A).quotKerEquivOfSurjective + (twoVariableNormal_surjective K A)) + +@[simp] +theorem unitRelationQuotientEquiv_mk + (p : TateAlgebra A (Fin 2)) : + unitRelationQuotientEquiv K A (Submodule.Quotient.mk p) = + twoVariableNormal K A p := by + rw [unitRelationQuotientEquiv, LinearEquiv.trans_apply, + Submodule.quotEquivOfEq_mk, + LinearMap.quotKerEquivOfSurjective_apply_mk] + +end CompletedLaurent + +end Rigid diff --git a/Rigid/AffinoidAlgebra/CompletedLaurentTwoVariableRelation.lean b/Rigid/AffinoidAlgebra/CompletedLaurentTwoVariableRelation.lean new file mode 100644 index 0000000..d593472 --- /dev/null +++ b/Rigid/AffinoidAlgebra/CompletedLaurentTwoVariableRelation.lean @@ -0,0 +1,276 @@ +import Rigid.AffinoidAlgebra.CompletedLaurentRelation +import Rigid.AffinoidAlgebra.CompletedLaurentTwoVariableQuotient + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# The element `T - f` in the two-variable Laurent normal form + +After imposing `TS = 1`, multiplication by `T - f` becomes the Laurent coefficient recurrence +`c(z - 1) - f c(z)`. This file proves that compatibility directly from coefficients. +-/ + +universe u v + +namespace Rigid + +namespace CompletedLaurent + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +/-- Multiplication by `T - f` in the first variable of `A⟨T,S⟩`. -/ +noncomputable def firstVariableRelation (f : A) : + TateAlgebra A (Fin 2) →ₗ[K] TateAlgebra A (Fin 2) where + toFun p := + (tateVariable A (Fin 2) 0 - TateAlgebra.C A (Fin 2) f) * p + map_add' p q := by rw [mul_add] + map_smul' c p := by rw [RingHom.id_apply, mul_smul_comm] + +private theorem firstExponent_eq : + Finsupp.single 0 1 = twoExponent 1 0 := by + apply Finsupp.ext + intro i + fin_cases i <;> simp [twoExponent] + +private theorem coe_firstVariable : + ((tateVariable A (Fin 2) 0 : TateAlgebra A (Fin 2)) : + MvPowerSeries (Fin 2) A) = + MvPowerSeries.monomial (twoExponent 1 0) 1 := by + change MvPowerSeries.X 0 = MvPowerSeries.monomial (twoExponent 1 0) 1 + rw [MvPowerSeries.X_def] + rw [firstExponent_eq] + +/-- Coefficients of multiplication by `T - f`. -/ +theorem coeff_firstVariableRelation + (f : A) (p : TateAlgebra A (Fin 2)) (e : Fin 2 →₀ ℕ) : + TateAlgebra.coeff A (Fin 2) e (firstVariableRelation K A f p) = + (if twoExponent 1 0 ≤ e then + TateAlgebra.coeff A (Fin 2) (e - twoExponent 1 0) p else 0) - + f * TateAlgebra.coeff A (Fin 2) e p := by + change MvPowerSeries.coeff e + ((((tateVariable A (Fin 2) 0 - TateAlgebra.C A (Fin 2) f) * p : + TateAlgebra A (Fin 2))) : MvPowerSeries (Fin 2) A) = _ + have hcoe : + ((((tateVariable A (Fin 2) 0 - TateAlgebra.C A (Fin 2) f) * p : + TateAlgebra A (Fin 2))) : MvPowerSeries (Fin 2) A) = + (MvPowerSeries.monomial (twoExponent 1 0) 1 - MvPowerSeries.C f) * p.1 := by + change + (((tateVariable A (Fin 2) 0 : TateAlgebra A (Fin 2)) : + MvPowerSeries (Fin 2) A) - MvPowerSeries.C f) * p.1 = + (MvPowerSeries.monomial (twoExponent 1 0) 1 - MvPowerSeries.C f) * p.1 + rw [coe_firstVariable] + rw [hcoe, sub_mul, map_sub, MvPowerSeries.coeff_monomial_mul, + MvPowerSeries.coeff_C_mul, one_mul] + rfl + +private theorem firstExponent_le_twoExponent_iff (i j : ℕ) : + twoExponent 1 0 ≤ twoExponent i j ↔ 0 < i := by + constructor + · intro h + have h0 := h 0 + have h0' : 1 ≤ i := by + simpa only [twoExponent_apply_zero] using h0 + omega + · intro hi k + fin_cases k + · simpa [twoExponent] using (Nat.succ_le_iff.mpr hi) + · simp [twoExponent] + +private theorem twoExponent_sub_first (i j : ℕ) (_hi : 0 < i) : + twoExponent i j - twoExponent 1 0 = twoExponent (i - 1) j := by + apply Finsupp.ext + intro k + fin_cases k <;> simp + +private theorem coeff_firstVariableRelation_twoExponent + (f : A) (p : TateAlgebra A (Fin 2)) (i j : ℕ) : + TateAlgebra.coeff A (Fin 2) (twoExponent i j) + (firstVariableRelation K A f p) = + (if 0 < i then + TateAlgebra.coeff A (Fin 2) (twoExponent (i - 1) j) p else 0) - + f * TateAlgebra.coeff A (Fin 2) (twoExponent i j) p := by + rw [coeff_firstVariableRelation] + by_cases hi : 0 < i + · rw [if_pos hi, if_pos ((firstExponent_le_twoExponent_iff i j).2 hi), + twoExponent_sub_first i j hi] + · rw [if_neg hi, if_neg (by + simpa [firstExponent_le_twoExponent_iff] using hi)] + +private theorem coeff_firstVariable_mul_twoExponent + (p : TateAlgebra A (Fin 2)) (i j : ℕ) : + TateAlgebra.coeff A (Fin 2) (twoExponent i j) + ((tateVariable A (Fin 2) 0 : TateAlgebra A (Fin 2)) * p) = + if 0 < i then + TateAlgebra.coeff A (Fin 2) (twoExponent (i - 1) j) p else 0 := by + change MvPowerSeries.coeff (twoExponent i j) + (MvPowerSeries.X 0 * p.1) = _ + rw [MvPowerSeries.X_def, MvPowerSeries.coeff_monomial_mul, one_mul] + rw [firstExponent_eq] + by_cases hi : 0 < i + · rw [if_pos hi, if_pos ((firstExponent_le_twoExponent_iff i j).2 hi), + twoExponent_sub_first i j hi] + rfl + · rw [if_neg hi, if_neg (by + simpa [firstExponent_le_twoExponent_iff] using hi)] + +private theorem negativeDiagonal_firstVariable + (p : TateAlgebra A (Fin 2)) (d : ℕ) : + (∑' n : ℕ, TateAlgebra.coeff A (Fin 2) (twoExponent n (d + n)) + ((tateVariable A (Fin 2) 0 : TateAlgebra A (Fin 2)) * p)) = + ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) (twoExponent n (d + 1 + n)) p := by + let a : ℕ → A := fun n ↦ + TateAlgebra.coeff A (Fin 2) (twoExponent n (d + 1 + n)) p + have ha : Summable a := by + exact negativeDiagonal_summable A p (d + 1) + calc + (∑' n : ℕ, TateAlgebra.coeff A (Fin 2) (twoExponent n (d + n)) + ((tateVariable A (Fin 2) 0 : TateAlgebra A (Fin 2)) * p)) = + ∑' n : ℕ, match n with + | 0 => 0 + | m + 1 => a m := by + apply tsum_congr + intro n + cases n with + | zero => + rw [coeff_firstVariable_mul_twoExponent (A := A), if_neg (by omega)] + | succ m => + rw [coeff_firstVariable_mul_twoExponent (A := A), if_pos (by omega)] + simp only [a] + congr 2 + omega + _ = 0 + ∑' n : ℕ, a n := by + rw [tsum_eq_zero_add' (by simpa using ha)] + _ = ∑' n : ℕ, TateAlgebra.coeff A (Fin 2) + (twoExponent n (d + 1 + n)) p := by simp only [zero_add, a] + +private theorem diagonalCoefficient_firstVariable + (p : TateAlgebra A (Fin 2)) (z : ℤ) : + diagonalCoefficient A + ((tateVariable A (Fin 2) 0 : TateAlgebra A (Fin 2)) * p) z = + diagonalCoefficient A p (z - 1) := by + rcases lt_trichotomy z 0 with hzneg | rfl | hzpos + · rw [diagonalCoefficient_of_neg A _ z hzneg, + diagonalCoefficient_of_neg A p (z - 1) (by omega)] + have htoNat : (-(z - 1)).toNat = (-z).toNat + 1 := by + calc + (-(z - 1)).toNat = (-z + 1).toNat := by + congr 1 + omega + _ = (-z).toNat + (1 : ℤ).toNat := + Int.toNat_add (by omega) (by omega) + _ = (-z).toNat + 1 := by simp + rw [htoNat] + exact negativeDiagonal_firstVariable A p (-z).toNat + · rw [diagonalCoefficient_of_nonneg A _ 0 (by omega), + diagonalCoefficient_of_neg A p (0 - 1) (by omega)] + simpa using negativeDiagonal_firstVariable A p 0 + · rw [diagonalCoefficient_of_nonneg A _ z hzpos.le, + diagonalCoefficient_of_nonneg A p (z - 1) (by omega)] + apply tsum_congr + intro n + rw [coeff_firstVariable_mul_twoExponent (A := A), if_pos (by + have hztoNat : 0 < z.toNat := by + have hcast : (z.toNat : ℤ) = z := + Int.toNat_of_nonneg hzpos.le + omega + omega)] + have htoNat : (z - 1).toNat = z.toNat - 1 := by + calc + (z - 1).toNat = ((z.toNat : ℤ) - (1 : ℕ)).toNat := by + congr 1 + rw [Int.toNat_of_nonneg hzpos.le] + norm_num + _ = z.toNat - 1 := Int.toNat_sub z.toNat 1 + rw [htoNat] + congr 2 + omega + +private theorem coeff_C_mul_twoVariable + (f : A) (p : TateAlgebra A (Fin 2)) (e : Fin 2 →₀ ℕ) : + TateAlgebra.coeff A (Fin 2) e (TateAlgebra.C A (Fin 2) f * p) = + f * TateAlgebra.coeff A (Fin 2) e p := by + change MvPowerSeries.coeff e (MvPowerSeries.C f * p.1) = + f * MvPowerSeries.coeff e p.1 + rw [MvPowerSeries.coeff_C_mul] + +private theorem diagonalCoefficient_C_mul + (f : A) (p : TateAlgebra A (Fin 2)) (z : ℤ) : + diagonalCoefficient A (TateAlgebra.C A (Fin 2) f * p) z = + f * diagonalCoefficient A p z := by + by_cases hz : 0 ≤ z + · rw [diagonalCoefficient_of_nonneg A _ z hz, + diagonalCoefficient_of_nonneg A p z hz] + simp_rw [coeff_C_mul_twoVariable A] + exact Summable.tsum_mul_left f (positiveDiagonal_summable A p z.toNat) + · have hzneg : z < 0 := lt_of_not_ge hz + rw [diagonalCoefficient_of_neg A _ z hzneg, + diagonalCoefficient_of_neg A p z hzneg] + simp_rw [coeff_C_mul_twoVariable A] + exact Summable.tsum_mul_left f (negativeDiagonal_summable A p (-z).toNat) + +/-- Diagonal normal form intertwines `T - f` with multiplication by `ζ - f`. -/ +theorem twoVariableNormal_firstVariableRelation + (f : A) (p : TateAlgebra A (Fin 2)) : + twoVariableNormal K A (firstVariableRelation K A f p) = + relation K A f (twoVariableNormal K A p) := by + apply Subtype.ext + funext z + change (twoVariableNormal K A + ((tateVariable A (Fin 2) 0 - TateAlgebra.C A (Fin 2) f) * p)).1 z = + diagonalCoefficient A p (z - 1) - f * diagonalCoefficient A p z + rw [sub_mul, map_sub] + change diagonalCoefficient A + ((tateVariable A (Fin 2) 0 : TateAlgebra A (Fin 2)) * p) z - + diagonalCoefficient A (TateAlgebra.C A (Fin 2) f * p) z = + diagonalCoefficient A p (z - 1) - f * diagonalCoefficient A p z + rw [diagonalCoefficient_firstVariable A, + diagonalCoefficient_C_mul A] + +/-- The simultaneous linear quotient by `TS - 1` and `T - f`. -/ +abbrev TwoRelationQuotient (f : A) := + UnitRelationQuotient K A ⧸ + Submodule.map (LinearMap.range (unitRelation K A)).mkQ + (LinearMap.range (firstVariableRelation K A f)) + +private theorem map_firstVariableRelationRange + (f : A) : + Submodule.map (unitRelationQuotientEquiv K A).toLinearMap + (Submodule.map (LinearMap.range (unitRelation K A)).mkQ + (LinearMap.range (firstVariableRelation K A f))) = + LinearMap.range (relation K A f) := by + ext c + constructor + · rintro ⟨q, ⟨p, ⟨r, rfl⟩, rfl⟩, rfl⟩ + refine ⟨twoVariableNormal K A r, ?_⟩ + symm + change unitRelationQuotientEquiv K A + (Submodule.Quotient.mk (firstVariableRelation K A f r)) = + relation K A f (twoVariableNormal K A r) + rw [unitRelationQuotientEquiv_mk, + twoVariableNormal_firstVariableRelation] + · rintro ⟨c, rfl⟩ + obtain ⟨p, rfl⟩ := twoVariableNormal_surjective K A c + refine ⟨Submodule.Quotient.mk (firstVariableRelation K A f p), ?_, ?_⟩ + · exact ⟨firstVariableRelation K A f p, ⟨p, rfl⟩, rfl⟩ + · change unitRelationQuotientEquiv K A + (Submodule.Quotient.mk (firstVariableRelation K A f p)) = + relation K A f (twoVariableNormal K A p) + rw [unitRelationQuotientEquiv_mk, + twoVariableNormal_firstVariableRelation] + +/-- The simultaneous two-variable quotient has the Laurent-recurrence normal form. -/ +noncomputable def twoRelationQuotientEquiv (f : A) : + TwoRelationQuotient K A f ≃ₗ[K] LaurentRelationQuotient K A f := + Submodule.Quotient.equiv + (Submodule.map (LinearMap.range (unitRelation K A)).mkQ + (LinearMap.range (firstVariableRelation K A f))) + (LinearMap.range (relation K A f)) + (unitRelationQuotientEquiv K A) + (map_firstVariableRelationRange K A f) + +end CompletedLaurent + +end Rigid diff --git a/Rigid/AffinoidAlgebra/LaurentCoverExact.lean b/Rigid/AffinoidAlgebra/LaurentCoverExact.lean new file mode 100644 index 0000000..e86f917 --- /dev/null +++ b/Rigid/AffinoidAlgebra/LaurentCoverExact.lean @@ -0,0 +1,75 @@ +import Rigid.AffinoidAlgebra.CompletedLaurentInjective +import Rigid.AffinoidAlgebra.CompletedLaurentQuotient + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# Exactness for a two-member Laurent cover + +This file completes the left and middle terms of the BGR completed Laurent diagram. The +codomain is, for the moment, the canonical quotient of restricted Laurent coefficients by +`ζ - f`; identifying that quotient with the iterated rational localization is kept as a separate +normal-form step. +-/ + +universe u v + +namespace Rigid + +namespace CompletedLaurent + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +/-- The diagonal map into the two Laurent rational charts is injective. -/ +theorem laurentCharts_diagonal_injective + (hA : IsAffinoidAlgebra K A) (f : A) : + Function.Injective (LaurentCharts.diagonal K A f) := by + apply (injective_iff_map_eq_zero (LaurentCharts.diagonal K A f)).mpr + intro a ha + let d : TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1) := + diagonal K A a + have hdker : d ∈ LinearMap.ker (chartQuotientMap K A f) := by + apply LinearMap.mem_ker.mpr + change LaurentCharts.diagonal K A f a = 0 + exact ha + rw [ker_chartQuotientMap K A hA f] at hdker + obtain ⟨pq, hpq⟩ := hdker + change chartRelations K A f pq = diagonal K A a at hpq + have hrelation : + relation K A f (relationFactor K A pq) = 0 := by + have hcomm := congrArg + (fun L : TateAlgebra A (Fin 1) × TateAlgebra A (Fin 1) →ₗ[K] Series K A ↦ L pq) + (difference_comp_chartRelations K A f) + rw [LinearMap.comp_apply, LinearMap.comp_apply] at hcomm + rw [← hcomm, hpq] + exact (exact K A).apply_apply_eq_zero a + have hfactor : relationFactor K A pq = 0 := by + apply relation_injective K A hA f + simpa using hrelation + have hpqzero : pq = 0 := by + apply relationFactor_injective K A + simpa using hfactor + have hd : diagonal K A a = 0 := by + rw [← hpq, hpqzero, map_zero] + have hd0 : diagonal K A a = diagonal K A 0 := by + simpa using hd + exact (shortExact K A).1 hd0 + +/-- The Laurent-cover sequence is short exact when the overlap is represented by restricted +Laurent coefficients modulo `ζ - f`. -/ +theorem auxiliary_shortExact + (hA : IsAffinoidAlgebra K A) (f : A) : + Function.Injective (LaurentCharts.diagonal K A f) ∧ + Function.Exact (LaurentCharts.diagonal K A f) + (auxiliaryDifference K A hA f) ∧ + Function.Surjective (auxiliaryDifference K A hA f) := + ⟨laurentCharts_diagonal_injective K A hA f, + auxiliary_exact K A hA f, + auxiliaryDifference_surjective K A hA f⟩ + +end CompletedLaurent + +end Rigid diff --git a/Rigid/AffinoidAlgebra/LaurentIntersection.lean b/Rigid/AffinoidAlgebra/LaurentIntersection.lean new file mode 100644 index 0000000..d8de042 --- /dev/null +++ b/Rigid/AffinoidAlgebra/LaurentIntersection.lean @@ -0,0 +1,260 @@ +import Rigid.AffinoidAlgebra.CompletedLaurentTwoVariableRelation +import Rigid.AffinoidAlgebra.CompletedLaurentQuotient +import Mathlib.LinearAlgebra.Isomorphisms + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# A direct rational localization for a Laurent intersection + +The locus `|f| = 1` is represented by the rational datum with denominator `f` and numerators +`f², 1`. Its two coordinates are therefore `T = f` and `S = f⁻¹`. The defining ideal agrees +with `(TS - 1, T - f)`, which connects this rational localization to the restricted Laurent +normal form. +-/ + +universe u v + +namespace Rigid + +namespace CompletedLaurent + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +/-- Numerators for the rational domain `|f| = 1`, ordered as `T = f` and `S = f⁻¹`. -/ +def laurentIntersectionNumerator (f : A) : Fin 2 → A := + ![f ^ 2, 1] + +/-- A direct rational localization representing the Laurent intersection `|f| = 1`. -/ +abbrev LaurentIntersection (f : A) := + RationalLocalization K A 2 f (laurentIntersectionNumerator A f) + +private noncomputable def unitGenerator : TateAlgebra A (Fin 2) := + tateVariable A (Fin 2) 0 * tateVariable A (Fin 2) 1 - 1 + +private noncomputable def firstGenerator (f : A) : TateAlgebra A (Fin 2) := + tateVariable A (Fin 2) 0 - TateAlgebra.C A (Fin 2) f + +private theorem range_mul_eq_span_singleton_restrictScalars + (r : TateAlgebra A (Fin 2)) + (μ : TateAlgebra A (Fin 2) →ₗ[K] TateAlgebra A (Fin 2)) + (hμ : ∀ p, μ p = r * p) : + LinearMap.range μ = + (Ideal.span ({r} : Set (TateAlgebra A (Fin 2)))).restrictScalars K := by + ext x + constructor + · rintro ⟨p, rfl⟩ + change μ p ∈ Ideal.span ({r} : Set (TateAlgebra A (Fin 2))) + rw [hμ] + exact Ideal.mem_span_singleton.mpr ⟨p, by rw [mul_comm]⟩ + · intro hx + change x ∈ Ideal.span ({r} : Set (TateAlgebra A (Fin 2))) at hx + obtain ⟨p, hp⟩ := Ideal.mem_span_singleton.mp hx + refine ⟨p, ?_⟩ + simpa [hμ] using hp.symm + +private theorem range_unitRelation : + LinearMap.range (unitRelation K A) = + (Ideal.span ({unitGenerator A} : + Set (TateAlgebra A (Fin 2)))).restrictScalars K := + range_mul_eq_span_singleton_restrictScalars K A (unitGenerator A) + (unitRelation K A) (fun _ ↦ rfl) + +private theorem range_firstVariableRelation (f : A) : + LinearMap.range (firstVariableRelation K A f) = + (Ideal.span ({firstGenerator A f} : + Set (TateAlgebra A (Fin 2)))).restrictScalars K := + range_mul_eq_span_singleton_restrictScalars K A (firstGenerator A f) + (firstVariableRelation K A f) (fun _ ↦ rfl) + +private theorem sup_relation_ranges (f : A) : + LinearMap.range (unitRelation K A) ⊔ + LinearMap.range (firstVariableRelation K A f) = + (Ideal.span ({unitGenerator A, firstGenerator A f} : + Set (TateAlgebra A (Fin 2)))).restrictScalars K := by + rw [range_unitRelation K A, range_firstVariableRelation K A f] + ext x + constructor + · intro hx + obtain ⟨y, hy, z, hz, rfl⟩ := Submodule.mem_sup.mp hx + change y ∈ Ideal.span ({unitGenerator A} : + Set (TateAlgebra A (Fin 2))) at hy + change z ∈ Ideal.span ({firstGenerator A f} : + Set (TateAlgebra A (Fin 2))) at hz + obtain ⟨a, ha⟩ := Ideal.mem_span_singleton.mp hy + obtain ⟨b, hb⟩ := Ideal.mem_span_singleton.mp hz + apply Ideal.mem_span_pair.mpr + exact ⟨a, b, by rw [ha, hb]; ring⟩ + · intro hx + change x ∈ Ideal.span ({unitGenerator A, firstGenerator A f} : + Set (TateAlgebra A (Fin 2))) at hx + obtain ⟨a, b, hab⟩ := Ideal.mem_span_pair.mp hx + apply Submodule.mem_sup.mpr + refine ⟨a * unitGenerator A, ?_, b * firstGenerator A f, ?_, hab⟩ + · change a * unitGenerator A ∈ + Ideal.span ({unitGenerator A} : Set (TateAlgebra A (Fin 2))) + exact (Ideal.span ({unitGenerator A} : + Set (TateAlgebra A (Fin 2)))).mul_mem_left a + (Ideal.mem_span_singleton_self (unitGenerator A)) + · change b * firstGenerator A f ∈ + Ideal.span ({firstGenerator A f} : Set (TateAlgebra A (Fin 2))) + exact (Ideal.span ({firstGenerator A f} : + Set (TateAlgebra A (Fin 2)))).mul_mem_left b + (Ideal.mem_span_singleton_self (firstGenerator A f)) + +private noncomputable def rationalFirstGenerator (f : A) : + TateAlgebra A (Fin 2) := + TateAlgebra.C A (Fin 2) f * tateVariable A (Fin 2) 0 - + TateAlgebra.C A (Fin 2) (f ^ 2) + +private noncomputable def rationalSecondGenerator (f : A) : + TateAlgebra A (Fin 2) := + TateAlgebra.C A (Fin 2) f * tateVariable A (Fin 2) 1 - 1 + +private theorem relationIdeal_eq_rationalIdeal (f : A) : + Ideal.span ({unitGenerator A, firstGenerator A f} : + Set (TateAlgebra A (Fin 2))) = + Ideal.span ({rationalFirstGenerator A f, rationalSecondGenerator A f} : + Set (TateAlgebra A (Fin 2))) := by + apply le_antisymm + · apply Ideal.span_le.mpr + rintro x (rfl | rfl) + · apply Ideal.mem_span_pair.mpr + refine ⟨tateVariable A (Fin 2) 1 ^ 2, + 1 - tateVariable A (Fin 2) 1 * firstGenerator A f, ?_⟩ + simp only [unitGenerator, firstGenerator, rationalFirstGenerator, + rationalSecondGenerator, map_pow] + ring + · apply Ideal.mem_span_pair.mpr + refine ⟨tateVariable A (Fin 2) 1, + -(firstGenerator A f), ?_⟩ + simp only [firstGenerator, rationalFirstGenerator, + rationalSecondGenerator, map_pow] + ring + · apply Ideal.span_le.mpr + rintro x (rfl | rfl) + · apply Ideal.mem_span_pair.mpr + refine ⟨0, TateAlgebra.C A (Fin 2) f, ?_⟩ + simp only [unitGenerator, firstGenerator, rationalFirstGenerator, + map_pow, zero_mul, zero_add] + ring + · apply Ideal.mem_span_pair.mpr + refine ⟨1, -tateVariable A (Fin 2) 1, ?_⟩ + simp only [unitGenerator, firstGenerator, rationalSecondGenerator, + one_mul] + ring + +private theorem relativeTate_two_isNoetherian + (hA : IsAffinoidAlgebra K A) : + IsNoetherianRing (TateAlgebra A (Fin 2)) := by + obtain ⟨m, π, hπ⟩ := + exists_equivalent_quotientNorm_presentation_of_presentation_topology_eq K A + hA.presentation.n hA.presentation.ideal hA.presentation.equiv + (topology_eq_affinoidTopology_of_presentation K A + hA.presentation.n hA.presentation.ideal hA.presentation.equiv) + exact isNoetherianRing_of_affinoidAlgebra K + (isAffinoidAlgebra_relativeTateAlgebra_of_surjective K A m π hπ.surjective 2) + +private theorem rational_generator_range (f : A) : + Set.range (fun i : Fin 2 ↦ + TateAlgebra.C A (Fin 2) f * tateVariable A (Fin 2) i - + TateAlgebra.C A (Fin 2) (laurentIntersectionNumerator A f i)) = + {rationalFirstGenerator A f, rationalSecondGenerator A f} := by + ext x + constructor + · rintro ⟨i, rfl⟩ + fin_cases i + · exact Or.inl rfl + · exact Or.inr (Set.mem_singleton _) + · rintro (rfl | rfl) + · exact ⟨0, rfl⟩ + · exact ⟨1, rfl⟩ + +theorem sup_relation_ranges_eq_rationalLocalizationIdeal + (hA : IsAffinoidAlgebra K A) (f : A) : + LinearMap.range (unitRelation K A) ⊔ + LinearMap.range (firstVariableRelation K A f) = + (rationalLocalizationIdeal A 2 f + (laurentIntersectionNumerator A f)).restrictScalars K := by + letI : IsNoetherianRing (TateAlgebra A (Fin 2)) := + relativeTate_two_isNoetherian K A hA + let J : Ideal (TateAlgebra A (Fin 2)) := + Ideal.span ({rationalFirstGenerator A f, rationalSecondGenerator A f} : + Set (TateAlgebra A (Fin 2))) + have hJclosed : IsClosed (J : Set (TateAlgebra A (Fin 2))) := + isClosed_ideal_of_isNoetherianRing K J + rw [sup_relation_ranges K A f, relationIdeal_eq_rationalIdeal A f] + change J.restrictScalars K = + (rationalLocalizationIdeal A 2 f + (laurentIntersectionNumerator A f)).restrictScalars K + rw [rationalLocalizationIdeal, rational_generator_range A f, + Ideal.closure_eq_of_isClosed J hJclosed] + +private theorem ker_laurentIntersectionQuotientMap + (hA : IsAffinoidAlgebra K A) (f : A) : + LinearMap.ker + (RationalLocalization.quotientMap K A 2 f + (laurentIntersectionNumerator A f)).toLinearMap = + LinearMap.range (unitRelation K A) ⊔ + LinearMap.range (firstVariableRelation K A f) := by + rw [sup_relation_ranges_eq_rationalLocalizationIdeal K A hA f] + ext p + change + RationalLocalization.quotientMap K A 2 f + (laurentIntersectionNumerator A f) p = 0 ↔ + p ∈ rationalLocalizationIdeal A 2 f + (laurentIntersectionNumerator A f) + exact Ideal.Quotient.eq_zero_iff_mem + +/-- The direct rational localization of `|f| = 1` has the restricted Laurent normal form. -/ +noncomputable def twoRelationQuotientEquivLaurentIntersection + (hA : IsAffinoidAlgebra K A) (f : A) : + TwoRelationQuotient K A f ≃ₗ[K] LaurentIntersection K A f := + (Submodule.quotientQuotientEquivQuotientSup + (LinearMap.range (unitRelation K A)) + (LinearMap.range (firstVariableRelation K A f))).trans + ((Submodule.quotEquivOfEq + (LinearMap.range (unitRelation K A) ⊔ + LinearMap.range (firstVariableRelation K A f)) + (LinearMap.ker + (RationalLocalization.quotientMap K A 2 f + (laurentIntersectionNumerator A f)).toLinearMap) + (ker_laurentIntersectionQuotientMap K A hA f).symm).trans + ((RationalLocalization.quotientMap K A 2 f + (laurentIntersectionNumerator A f)).toLinearMap.quotKerEquivOfSurjective + Ideal.Quotient.mk_surjective)) + +/-- The completed Laurent recurrence quotient is the direct Laurent intersection algebra. -/ +noncomputable def laurentRelationQuotientEquivLaurentIntersection + (hA : IsAffinoidAlgebra K A) (f : A) : + LaurentRelationQuotient K A f ≃ₗ[K] LaurentIntersection K A f := + (twoRelationQuotientEquiv K A f).symm.trans + (twoRelationQuotientEquivLaurentIntersection K A hA f) + +@[simp] +theorem laurentRelationQuotientEquivLaurentIntersection_mk + (hA : IsAffinoidAlgebra K A) (f : A) (c : Series K A) : + laurentRelationQuotientEquivLaurentIntersection K A hA f + (Submodule.Quotient.mk c) = + RationalLocalization.quotientMap K A 2 f + (laurentIntersectionNumerator A f) (axisSeries K A c) := by + let x : TwoRelationQuotient K A f := + Submodule.Quotient.mk + (Submodule.Quotient.mk (axisSeries K A c)) + have hx : + twoRelationQuotientEquiv K A f x = Submodule.Quotient.mk c := by + change Submodule.Quotient.mk + (unitRelationQuotientEquiv K A + (Submodule.Quotient.mk (axisSeries K A c))) = + Submodule.Quotient.mk c + rw [unitRelationQuotientEquiv_mk, twoVariableNormal_axisSeries] + rw [← hx, laurentRelationQuotientEquivLaurentIntersection, + LinearEquiv.trans_apply, LinearEquiv.symm_apply_apply] + rfl + +end CompletedLaurent + +end Rigid diff --git a/Rigid/AffinoidAlgebra/LaurentIntersectionMaps.lean b/Rigid/AffinoidAlgebra/LaurentIntersectionMaps.lean new file mode 100644 index 0000000..babbe31 --- /dev/null +++ b/Rigid/AffinoidAlgebra/LaurentIntersectionMaps.lean @@ -0,0 +1,859 @@ +import Rigid.AffinoidAlgebra.LaurentCoverExact +import Rigid.AffinoidAlgebra.LaurentIntersection +import Mathlib.RingTheory.MvPowerSeries.Rename + +set_option linter.style.header false +set_option linter.unusedSectionVars false + +/-! +# The Laurent chart maps into the direct intersection + +This file connects the completed Laurent normal form to the actual restriction maps. The +intersection `|f| = 1` is represented directly by the rational datum `(f; f², 1)`. Its +coordinates are the images of `f` and `f⁻¹`, so both one-variable Laurent charts map to it. +-/ + +open Filter + +universe u v + +namespace Rigid + +namespace CompletedLaurent + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +/-- The datum `(f; f², 1)` is rational because one of its numerators is `1`. -/ +theorem laurentIntersection_isRational (f : A) : + IsRationalDatum f (laurentIntersectionNumerator A f) := by + rw [IsRationalDatum] + apply (Ideal.eq_top_iff_one _).mpr + apply Ideal.subset_span + right + exact ⟨1, by simp [laurentIntersectionNumerator]⟩ + +/-- The ambient map into the direct Laurent intersection. -/ +noncomputable def laurentIntersectionMap (f : A) : + ContinuousAlgHom K A (LaurentIntersection K A f) := + RationalLocalization.baseMap K A 2 f (laurentIntersectionNumerator A f) + +/-- The coordinate which equals `f` on the direct Laurent intersection. -/ +noncomputable def laurentIntersectionT (f : A) : LaurentIntersection K A f := + RationalLocalization.coordinate K A 2 f (laurentIntersectionNumerator A f) 0 + +/-- The coordinate which equals `f⁻¹` on the direct Laurent intersection. -/ +noncomputable def laurentIntersectionS (f : A) : LaurentIntersection K A f := + RationalLocalization.coordinate K A 2 f (laurentIntersectionNumerator A f) 1 + +theorem isPowerBounded_laurentIntersectionT (f : A) : + IsPowerBounded (laurentIntersectionT K A f) := + RationalLocalization.isPowerBounded_coordinate K A 2 f + (laurentIntersectionNumerator A f) 0 + +theorem isPowerBounded_laurentIntersectionS (f : A) : + IsPowerBounded (laurentIntersectionS K A f) := + RationalLocalization.isPowerBounded_coordinate K A 2 f + (laurentIntersectionNumerator A f) 1 + +@[simp] +theorem laurentIntersectionMap_mul_S (f : A) : + laurentIntersectionMap K A f f * laurentIntersectionS K A f = 1 := by + exact RationalLocalization.baseMap_denominator_mul_coordinate K A 2 f + (laurentIntersectionNumerator A f) 1 + +@[simp] +theorem laurentIntersectionT_eq_map (f : A) : + laurentIntersectionT K A f = laurentIntersectionMap K A f f := by + have hunit : + IsUnit (laurentIntersectionMap K A f f) := + RationalLocalization.isUnit_baseMap_denominator K A 2 f + (laurentIntersectionNumerator A f) (laurentIntersection_isRational A f) + apply hunit.mul_left_cancel + change + RationalLocalization.baseMap K A 2 f (laurentIntersectionNumerator A f) f * + RationalLocalization.coordinate K A 2 f + (laurentIntersectionNumerator A f) 0 = + RationalLocalization.baseMap K A 2 f (laurentIntersectionNumerator A f) f * + RationalLocalization.baseMap K A 2 f + (laurentIntersectionNumerator A f) f + rw [RationalLocalization.baseMap_denominator_mul_coordinate] + change + RationalLocalization.baseMap K A 2 f (laurentIntersectionNumerator A f) (f ^ 2) = + RationalLocalization.baseMap K A 2 f (laurentIntersectionNumerator A f) f * + RationalLocalization.baseMap K A 2 f (laurentIntersectionNumerator A f) f + rw [map_pow, pow_two] + +/-- Restriction from the positive Laurent chart to the direct intersection. -/ +noncomputable def plusToLaurentIntersection (f : A) : + ContinuousAlgHom K (LaurentCharts.Plus K A f) (LaurentIntersection K A f) := + RationalLocalization.lift K A 1 1 (fun _ ↦ f) + (laurentIntersectionMap K A f) (fun _ ↦ laurentIntersectionT K A f) + (fun _ ↦ isPowerBounded_laurentIntersectionT K A f) + (fun _ ↦ by simp) + +/-- Restriction from the negative Laurent chart to the direct intersection. -/ +noncomputable def minusToLaurentIntersection (f : A) : + ContinuousAlgHom K (LaurentCharts.Minus K A f) (LaurentIntersection K A f) := + RationalLocalization.lift K A 1 f (fun _ ↦ 1) + (laurentIntersectionMap K A f) (fun _ ↦ laurentIntersectionS K A f) + (fun _ ↦ isPowerBounded_laurentIntersectionS K A f) + (fun _ ↦ by simp) + +@[simp] +theorem plusToLaurentIntersection_comp_plusMap (f : A) : + (plusToLaurentIntersection K A f).comp (LaurentCharts.plusMap K A f) = + laurentIntersectionMap K A f := + RationalLocalization.lift_comp_baseMap K A 1 1 (fun _ ↦ f) + (laurentIntersectionMap K A f) (fun _ ↦ laurentIntersectionT K A f) + (fun _ ↦ isPowerBounded_laurentIntersectionT K A f) (fun _ ↦ by simp) + +@[simp] +theorem minusToLaurentIntersection_comp_minusMap (f : A) : + (minusToLaurentIntersection K A f).comp (LaurentCharts.minusMap K A f) = + laurentIntersectionMap K A f := + RationalLocalization.lift_comp_baseMap K A 1 f (fun _ ↦ 1) + (laurentIntersectionMap K A f) (fun _ ↦ laurentIntersectionS K A f) + (fun _ ↦ isPowerBounded_laurentIntersectionS K A f) (fun _ ↦ by simp) + +/-- Difference of restriction maps with values in the direct Laurent intersection. -/ +noncomputable def directDifference (f : A) : + LaurentCharts.Plus K A f × LaurentCharts.Minus K A f →ₗ[K] + LaurentIntersection K A f := + (plusToLaurentIntersection K A f).toLinearMap.comp (LinearMap.fst K _ _) - + (minusToLaurentIntersection K A f).toLinearMap.comp (LinearMap.snd K _ _) + +@[simp] +theorem directDifference_apply (f : A) + (p : LaurentCharts.Plus K A f) (q : LaurentCharts.Minus K A f) : + directDifference K A f (p, q) = + plusToLaurentIntersection K A f p - minusToLaurentIntersection K A f q := + rfl + +private noncomputable def axisEmbedding (i : Fin 2) : Fin 1 ↪ Fin 2 where + toFun := fun _ ↦ i + inj' x y _ := Subsingleton.elim x y + +private noncomputable def algebraicAxisMap (i : Fin 2) : + TateAlgebra A (Fin 1) →ₐ[K] TateAlgebra A (Fin 2) := by + let e := axisEmbedding i + refine + { toFun := fun p ↦ ⟨MvPowerSeries.rename e p.1, ?_⟩ + map_one' := Subtype.ext (map_one (MvPowerSeries.rename e)) + map_mul' := fun p q ↦ Subtype.ext (map_mul (MvPowerSeries.rename e) p.1 q.1) + map_zero' := Subtype.ext (map_zero (MvPowerSeries.rename e)) + map_add' := fun p q ↦ Subtype.ext (map_add (MvPowerSeries.rename e) p.1 q.1) + commutes' := fun c ↦ Subtype.ext (by + change MvPowerSeries.rename e (MvPowerSeries.C (algebraMap K A c)) = + MvPowerSeries.C (algebraMap K A c) + simp) } + change MvPowerSeries.IsRestricted (fun _ : Fin 2 ↦ (1 : ℝ)) + (MvPowerSeries.rename e p.1) + have hrename : Tendsto + (fun x : Fin 2 →₀ ℕ ↦ + ‖MvPowerSeries.coeff x (MvPowerSeries.rename e p.1)‖) cofinite (nhds 0) := by + rw [tendsto_def] + intro s hs + have hzero : (0 : ℝ) ∈ s := mem_of_mem_nhds hs + have hp : {x : Fin 1 →₀ ℕ | ‖MvPowerSeries.coeff x p.1‖ ∈ s} ∈ cofinite := + (tendsto_norm_coeff_zero A (Fin 1) p).eventually hs + rw [mem_cofinite] at hp ⊢ + refine hp.image (Finsupp.embDomain e) |>.subset ?_ + intro x hx + simp only [Set.mem_compl_iff] at hx ⊢ + by_cases hxr : x ∈ Set.range (Finsupp.embDomain e) + · obtain ⟨y, rfl⟩ := hxr + refine ⟨y, ?_, rfl⟩ + simpa using hx + · exfalso + apply hx + change ‖MvPowerSeries.coeff x (MvPowerSeries.rename e p.1)‖ ∈ s + rw [MvPowerSeries.coeff_rename_eq_zero] + · simpa using hzero + · simpa [Finsupp.embDomain_eq_mapDomain] using hxr + simpa [MvPowerSeries.IsRestricted, Finsupp.prod] using hrename + +private theorem norm_algebraicAxisMap_le (i : Fin 2) (p : TateAlgebra A (Fin 1)) : + ‖algebraicAxisMap K A i p‖ ≤ ‖p‖ := by + rw [norm_eq_sSup_coeff] + refine csSup_le (Set.range_nonempty _) ?_ + rintro _ ⟨e, rfl⟩ + by_cases he : e ∈ Set.range (Finsupp.embDomain (axisEmbedding i)) + · obtain ⟨d, rfl⟩ := he + change ‖MvPowerSeries.coeff (Finsupp.embDomain (axisEmbedding i) d) + (MvPowerSeries.rename (axisEmbedding i) p.1)‖ ≤ ‖p‖ + rw [MvPowerSeries.coeff_embDomain_rename] + exact norm_coeff_le_norm A (Fin 1) p d + · change ‖MvPowerSeries.coeff e + (MvPowerSeries.rename (axisEmbedding i) p.1)‖ ≤ ‖p‖ + rw [MvPowerSeries.coeff_rename_eq_zero] + · simp + · simpa [Finsupp.embDomain_eq_mapDomain] using he + +/-- Embed a one-variable Tate algebra along one of the two coordinate axes. -/ +noncomputable def axisMap (i : Fin 2) : + ContinuousAlgHom K (TateAlgebra A (Fin 1)) (TateAlgebra A (Fin 2)) := + { algebraicAxisMap K A i with + cont := AddMonoidHomClass.continuous_of_bound + (algebraicAxisMap K A i) 1 (fun p ↦ by + simpa using norm_algebraicAxisMap_le K A i p) } + +@[simp] +theorem axisMap_C (i : Fin 2) (a : A) : + axisMap K A i (TateAlgebra.C A (Fin 1) a) = + TateAlgebra.C A (Fin 2) a := by + apply Subtype.ext + simp [axisMap, algebraicAxisMap] + +@[simp] +theorem axisMap_tateVariable (i : Fin 2) : + axisMap K A i (tateVariable A (Fin 1) 0) = + tateVariable A (Fin 2) i := by + apply Subtype.ext + change MvPowerSeries.rename (axisEmbedding i) + (MvPowerSeries.X 0 : MvPowerSeries (Fin 1) A) = + (MvPowerSeries.X i : MvPowerSeries (Fin 2) A) + simp [axisEmbedding] + +private theorem embDomain_axis_zero_oneExponent (n : ℕ) : + Finsupp.embDomain (axisEmbedding (0 : Fin 2)) (oneExponent n) = + twoExponent n 0 := by + ext i + fin_cases i <;> + simp [axisEmbedding, oneExponent, twoExponent] + +private theorem embDomain_axis_one_oneExponent (n : ℕ) : + Finsupp.embDomain (axisEmbedding (1 : Fin 2)) (oneExponent n) = + twoExponent 0 n := by + ext i + fin_cases i <;> + simp [axisEmbedding, oneExponent, twoExponent] + +private theorem coeff_axisMap_zero (p : TateAlgebra A (Fin 1)) (i j : ℕ) : + TateAlgebra.coeff A (Fin 2) (twoExponent i j) (axisMap K A 0 p) = + if j = 0 then TateAlgebra.coeff A (Fin 1) (oneExponent i) p else 0 := by + by_cases hj : j = 0 + · subst j + rw [if_pos rfl, ← embDomain_axis_zero_oneExponent i] + exact MvPowerSeries.coeff_embDomain_rename (axisEmbedding (0 : Fin 2)) p.1 + (oneExponent i) + · rw [if_neg hj] + change MvPowerSeries.coeff (twoExponent i j) + (MvPowerSeries.rename (axisEmbedding (0 : Fin 2)) p.1) = 0 + apply MvPowerSeries.coeff_rename_eq_zero + intro hrange + obtain ⟨d, hd⟩ := hrange + rw [← Finsupp.embDomain_eq_mapDomain] at hd + have h1 := congrArg (fun e : Fin 2 →₀ ℕ ↦ e 1) hd + simp [axisEmbedding, twoExponent, Finsupp.embDomain_apply] at h1 + exact hj h1.symm + +private theorem coeff_axisMap_one (p : TateAlgebra A (Fin 1)) (i j : ℕ) : + TateAlgebra.coeff A (Fin 2) (twoExponent i j) (axisMap K A 1 p) = + if i = 0 then TateAlgebra.coeff A (Fin 1) (oneExponent j) p else 0 := by + by_cases hi : i = 0 + · subst i + rw [if_pos rfl, ← embDomain_axis_one_oneExponent j] + exact MvPowerSeries.coeff_embDomain_rename (axisEmbedding (1 : Fin 2)) p.1 + (oneExponent j) + · rw [if_neg hi] + change MvPowerSeries.coeff (twoExponent i j) + (MvPowerSeries.rename (axisEmbedding (1 : Fin 2)) p.1) = 0 + apply MvPowerSeries.coeff_rename_eq_zero + intro hrange + obtain ⟨d, hd⟩ := hrange + rw [← Finsupp.embDomain_eq_mapDomain] at hd + have h0 := congrArg (fun e : Fin 2 →₀ ℕ ↦ e 0) hd + simp [axisEmbedding, twoExponent, Finsupp.embDomain_apply] at h0 + exact hi h0.symm + +theorem axisSeries_positive (p : TateAlgebra A (Fin 1)) : + axisSeries K A (positive K A p) = axisMap K A 0 p := by + ext e + have he : e = twoExponent (e 0) (e 1) := by + ext i + fin_cases i <;> simp + rw [he] + rw [coeff_axisSeries_twoExponent, coeff_axisMap_zero] + by_cases hj : e 1 = 0 + · simp [hj, positive] + · by_cases hi : e 0 = 0 + · simp [hi, hj, positive] + · simp [hi, hj] + +theorem axisSeries_negative (p : TateAlgebra A (Fin 1)) : + axisSeries K A (negative K A p) = axisMap K A 1 p := by + ext e + have he : e = twoExponent (e 0) (e 1) := by + ext i + fin_cases i <;> simp + rw [he] + rw [coeff_axisSeries_twoExponent, coeff_axisMap_one] + by_cases hi : e 0 = 0 + · simp [hi, negative, positive] + · by_cases hj : e 1 = 0 + · simp [hi, hj, negative, positive] + · simp [hi, hj] + +theorem axisSeries_difference + (p q : TateAlgebra A (Fin 1)) : + axisSeries K A (difference K A (p, q)) = + axisMap K A 0 p - axisMap K A 1 q := by + ext e + have he : e = twoExponent (e 0) (e 1) := by + ext i + fin_cases i <;> simp + rw [he] + rw [coeff_axisSeries_twoExponent] + change + (if e 0 = 0 ∨ e 1 = 0 then + (difference K A (p, q)).1 ((e 0 : ℤ) - (e 1 : ℤ)) else 0) = + TateAlgebra.coeff A (Fin 2) (twoExponent (e 0) (e 1)) + (axisMap K A 0 p) - + TateAlgebra.coeff A (Fin 2) (twoExponent (e 0) (e 1)) + (axisMap K A 1 q) + rw [coeff_axisMap_zero, coeff_axisMap_one] + by_cases hi : e 0 = 0 + · by_cases hj : e 1 = 0 + · simp [hi, hj, difference, positive, negative] + · simp [hi, hj, difference, positive, negative] + · by_cases hj : e 1 = 0 + · simp [hi, hj, difference, positive, negative] + · simp [hi, hj] + +theorem plusToLaurentIntersection_comp_quotientMap (f : A) : + (plusToLaurentIntersection K A f).comp + (RationalLocalization.quotientMap K A 1 1 (fun _ ↦ f)) = + (RationalLocalization.quotientMap K A 2 f + (laurentIntersectionNumerator A f)).comp (axisMap K A 0) := by + apply RelativeTateAlgebra.hom_ext K A + · intro a + simp only [ContinuousAlgHom.comp_apply, RationalLocalization.quotientMap_C, + axisMap_C] + change + plusToLaurentIntersection K A f + (LaurentCharts.plusMap K A f a) = + laurentIntersectionMap K A f a + exact congrArg + (fun φ : ContinuousAlgHom K A (LaurentIntersection K A f) ↦ φ a) + (plusToLaurentIntersection_comp_plusMap K A f) + · intro i + rw [Fin.eq_zero i] + simp only [ContinuousAlgHom.comp_apply, + RationalLocalization.quotientMap_tateVariable, axisMap_tateVariable, + plusToLaurentIntersection, RationalLocalization.lift_coordinate] + rfl + +theorem minusToLaurentIntersection_comp_quotientMap (f : A) : + (minusToLaurentIntersection K A f).comp + (RationalLocalization.quotientMap K A 1 f (fun _ ↦ 1)) = + (RationalLocalization.quotientMap K A 2 f + (laurentIntersectionNumerator A f)).comp (axisMap K A 1) := by + apply RelativeTateAlgebra.hom_ext K A + · intro a + simp only [ContinuousAlgHom.comp_apply, RationalLocalization.quotientMap_C, + axisMap_C] + change + minusToLaurentIntersection K A f + (LaurentCharts.minusMap K A f a) = + laurentIntersectionMap K A f a + exact congrArg + (fun φ : ContinuousAlgHom K A (LaurentIntersection K A f) ↦ φ a) + (minusToLaurentIntersection_comp_minusMap K A f) + · intro i + rw [Fin.eq_zero i] + simp only [ContinuousAlgHom.comp_apply, + RationalLocalization.quotientMap_tateVariable, axisMap_tateVariable, + minusToLaurentIntersection, RationalLocalization.lift_coordinate] + rfl + +theorem directDifference_eq_equiv_auxiliaryDifference + (hA : IsAffinoidAlgebra K A) (f : A) : + directDifference K A f = + (laurentRelationQuotientEquivLaurentIntersection K A hA f).toLinearMap.comp + (auxiliaryDifference K A hA f) := by + apply LinearMap.ext + intro z + obtain ⟨pq, rfl⟩ := chartQuotientMap_surjective K A f z + rcases pq with ⟨p, q⟩ + have hinv : + (chartRelationQuotientEquiv K A hA f).symm + (chartQuotientMap K A f (p, q)) = + Submodule.Quotient.mk (p, q) := by + apply (chartRelationQuotientEquiv K A hA f).injective + rw [LinearEquiv.apply_symm_apply, chartRelationQuotientEquiv_mk] + have hp := congrArg + (fun φ : ContinuousAlgHom K (TateAlgebra A (Fin 1)) + (LaurentIntersection K A f) ↦ φ p) + (plusToLaurentIntersection_comp_quotientMap K A f) + have hq := congrArg + (fun φ : ContinuousAlgHom K (TateAlgebra A (Fin 1)) + (LaurentIntersection K A f) ↦ φ q) + (minusToLaurentIntersection_comp_quotientMap K A f) + rw [LinearMap.comp_apply] + change + plusToLaurentIntersection K A f + (RationalLocalization.quotientMap K A 1 1 (fun _ ↦ f) p) - + minusToLaurentIntersection K A f + (RationalLocalization.quotientMap K A 1 f (fun _ ↦ 1) q) = + laurentRelationQuotientEquivLaurentIntersection K A hA f + (quotientDifference K A f + ((chartRelationQuotientEquiv K A hA f).symm + (chartQuotientMap K A f (p, q)))) + rw [hinv] + change + plusToLaurentIntersection K A f + (RationalLocalization.quotientMap K A 1 1 (fun _ ↦ f) p) - + minusToLaurentIntersection K A f + (RationalLocalization.quotientMap K A 1 f (fun _ ↦ 1) q) = + laurentRelationQuotientEquivLaurentIntersection K A hA f + (Submodule.Quotient.mk (difference K A (p, q))) + rw [laurentRelationQuotientEquivLaurentIntersection_mk, + axisSeries_difference, map_sub] + have hp' : + plusToLaurentIntersection K A f + (RationalLocalization.quotientMap K A 1 1 (fun _ ↦ f) p) = + RationalLocalization.quotientMap K A 2 f + (laurentIntersectionNumerator A f) (axisMap K A 0 p) := by + simpa only [ContinuousAlgHom.comp_apply] using hp + have hq' : + minusToLaurentIntersection K A f + (RationalLocalization.quotientMap K A 1 f (fun _ ↦ 1) q) = + RationalLocalization.quotientMap K A 2 f + (laurentIntersectionNumerator A f) (axisMap K A 1 q) := by + simpa only [ContinuousAlgHom.comp_apply] using hq + exact congrArg₂ (· - ·) hp' hq' + +/-- Tate's Laurent-cover sequence is short exact with the overlap represented by the direct +rational localization `(f; f², 1)`. -/ +theorem direct_shortExact + (hA : IsAffinoidAlgebra K A) (f : A) : + Function.Injective (LaurentCharts.diagonal K A f) ∧ + Function.Exact (LaurentCharts.diagonal K A f) (directDifference K A f) ∧ + Function.Surjective (directDifference K A f) := by + obtain ⟨hinj, hexact, hsurj⟩ := auxiliary_shortExact K A hA f + refine ⟨hinj, ?_, ?_⟩ + · rw [directDifference_eq_equiv_auxiliaryDifference K A hA f] + exact + (laurentRelationQuotientEquivLaurentIntersection K A hA f + |>.postcomp_exact_iff_exact).2 hexact + · rw [directDifference_eq_equiv_auxiliaryDifference K A hA f] + exact + (laurentRelationQuotientEquivLaurentIntersection K A hA f).surjective.comp hsurj + +private noncomputable def overlapT (f : A) : LaurentCharts.Overlap K A f := + LaurentCharts.plusToOverlap K A f + (RationalLocalization.coordinate K A 1 1 (fun _ ↦ f) 0) + +private theorem overlapT_eq_map (f : A) : + overlapT K A f = LaurentCharts.overlapMap K A f f := by + change + LaurentCharts.plusToOverlap K A f + (RationalLocalization.coordinate K A 1 1 (fun _ ↦ f) 0) = + LaurentCharts.plusToOverlap K A f (LaurentCharts.plusMap K A f f) + congr 1 + have h := RationalLocalization.baseMap_denominator_mul_coordinate K A 1 1 + (fun _ : Fin 1 ↦ f) 0 + change + RationalLocalization.coordinate K A 1 1 (fun _ ↦ f) 0 = + RationalLocalization.baseMap K A 1 1 (fun _ ↦ f) f + simpa using h + +private theorem isPowerBounded_overlapT (f : A) : + IsPowerBounded (overlapT K A f) := + (RationalLocalization.isPowerBounded_coordinate K A 1 1 + (fun _ ↦ f) 0).map_continuousAlgHom (LaurentCharts.plusToOverlap K A f) + +private noncomputable def overlapCoordinates (f : A) : + Fin 2 → LaurentCharts.Overlap K A f := + ![overlapT K A f, LaurentCharts.overlapInverse K A f] + +private theorem isPowerBounded_overlapCoordinates (f : A) (i : Fin 2) : + IsPowerBounded (overlapCoordinates K A f i) := by + fin_cases i + · exact isPowerBounded_overlapT K A f + · exact LaurentCharts.isPowerBounded_overlapInverse K A f + +private theorem overlapCoordinates_relation (f : A) (i : Fin 2) : + LaurentCharts.overlapMap K A f f * overlapCoordinates K A f i = + LaurentCharts.overlapMap K A f (laurentIntersectionNumerator A f i) := by + fin_cases i + · change + LaurentCharts.overlapMap K A f f * overlapT K A f = + LaurentCharts.overlapMap K A f (f ^ 2) + rw [overlapT_eq_map, map_pow, pow_two] + · change + LaurentCharts.overlapMap K A f f * LaurentCharts.overlapInverse K A f = + LaurentCharts.overlapMap K A f 1 + simp + +/-- Map the direct intersection `(f; f², 1)` to the iterated Laurent overlap. -/ +noncomputable def laurentIntersectionToOverlap (f : A) : + ContinuousAlgHom K (LaurentIntersection K A f) (LaurentCharts.Overlap K A f) := + RationalLocalization.lift K A 2 f (laurentIntersectionNumerator A f) + (LaurentCharts.overlapMap K A f) + (overlapCoordinates K A f) + (isPowerBounded_overlapCoordinates K A f) + (overlapCoordinates_relation K A f) + +@[simp] +theorem laurentIntersectionToOverlap_comp_map (f : A) : + (laurentIntersectionToOverlap K A f).comp (laurentIntersectionMap K A f) = + LaurentCharts.overlapMap K A f := + RationalLocalization.lift_comp_baseMap K A 2 f + (laurentIntersectionNumerator A f) (LaurentCharts.overlapMap K A f) + (overlapCoordinates K A f) + (isPowerBounded_overlapCoordinates K A f) + (overlapCoordinates_relation K A f) + +@[simp] +theorem laurentIntersectionToOverlap_T (f : A) : + laurentIntersectionToOverlap K A f (laurentIntersectionT K A f) = + overlapT K A f := by + exact RationalLocalization.lift_coordinate K A 2 f + (laurentIntersectionNumerator A f) (LaurentCharts.overlapMap K A f) + (overlapCoordinates K A f) + (isPowerBounded_overlapCoordinates K A f) + (overlapCoordinates_relation K A f) 0 + +@[simp] +theorem laurentIntersectionToOverlap_S (f : A) : + laurentIntersectionToOverlap K A f (laurentIntersectionS K A f) = + LaurentCharts.overlapInverse K A f := by + exact RationalLocalization.lift_coordinate K A 2 f + (laurentIntersectionNumerator A f) (LaurentCharts.overlapMap K A f) + (overlapCoordinates K A f) + (isPowerBounded_overlapCoordinates K A f) + (overlapCoordinates_relation K A f) 1 + +/-- Map the iterated Laurent overlap back to the direct rational localization. -/ +noncomputable def overlapToLaurentIntersection (f : A) : + ContinuousAlgHom K (LaurentCharts.Overlap K A f) (LaurentIntersection K A f) := + RationalLocalization.lift K (LaurentCharts.Plus K A f) 1 + (LaurentCharts.plusMap K A f f) (fun _ ↦ 1) + (plusToLaurentIntersection K A f) (fun _ ↦ laurentIntersectionS K A f) + (fun _ ↦ isPowerBounded_laurentIntersectionS K A f) + (fun _ ↦ by + have h := congrArg + (fun φ : ContinuousAlgHom K A (LaurentIntersection K A f) ↦ φ f) + (plusToLaurentIntersection_comp_plusMap K A f) + change + plusToLaurentIntersection K A f (LaurentCharts.plusMap K A f f) * + laurentIntersectionS K A f = + plusToLaurentIntersection K A f 1 + rw [show plusToLaurentIntersection K A f + (LaurentCharts.plusMap K A f f) = laurentIntersectionMap K A f f by + simpa only [ContinuousAlgHom.comp_apply] using h] + simp) + +@[simp] +theorem overlapToLaurentIntersection_comp_plusToOverlap (f : A) : + (overlapToLaurentIntersection K A f).comp + (LaurentCharts.plusToOverlap K A f) = + plusToLaurentIntersection K A f := by + exact RationalLocalization.lift_comp_baseMap K (LaurentCharts.Plus K A f) 1 + (LaurentCharts.plusMap K A f f) (fun _ ↦ 1) + (plusToLaurentIntersection K A f) (fun _ ↦ laurentIntersectionS K A f) + (fun _ ↦ isPowerBounded_laurentIntersectionS K A f) + (fun _ ↦ by + have h := congrArg + (fun φ : ContinuousAlgHom K A (LaurentIntersection K A f) ↦ φ f) + (plusToLaurentIntersection_comp_plusMap K A f) + rw [show plusToLaurentIntersection K A f + (LaurentCharts.plusMap K A f f) = laurentIntersectionMap K A f f by + simpa only [ContinuousAlgHom.comp_apply] using h] + simp) + +@[simp] +theorem overlapToLaurentIntersection_inverse (f : A) : + overlapToLaurentIntersection K A f (LaurentCharts.overlapInverse K A f) = + laurentIntersectionS K A f := by + exact RationalLocalization.lift_coordinate K (LaurentCharts.Plus K A f) 1 + (LaurentCharts.plusMap K A f f) (fun _ ↦ 1) + (plusToLaurentIntersection K A f) (fun _ ↦ laurentIntersectionS K A f) + (fun _ ↦ isPowerBounded_laurentIntersectionS K A f) + (fun _ ↦ by + have h := congrArg + (fun φ : ContinuousAlgHom K A (LaurentIntersection K A f) ↦ φ f) + (plusToLaurentIntersection_comp_plusMap K A f) + rw [show plusToLaurentIntersection K A f + (LaurentCharts.plusMap K A f f) = laurentIntersectionMap K A f f by + simpa only [ContinuousAlgHom.comp_apply] using h] + simp) 0 + +@[simp] +theorem laurentIntersectionToOverlap_comp_plusToLaurentIntersection (f : A) : + (laurentIntersectionToOverlap K A f).comp + (plusToLaurentIntersection K A f) = + LaurentCharts.plusToOverlap K A f := by + apply RationalLocalization.hom_ext K A 1 1 (fun _ ↦ f) + · apply ContinuousAlgHom.ext + intro a + simp only [ContinuousAlgHom.comp_apply] + have hplus := congrArg + (fun φ : ContinuousAlgHom K A (LaurentIntersection K A f) ↦ φ a) + (plusToLaurentIntersection_comp_plusMap K A f) + have hintersection := congrArg + (fun φ : ContinuousAlgHom K A (LaurentCharts.Overlap K A f) ↦ φ a) + (laurentIntersectionToOverlap_comp_map K A f) + have hoverlap := congrArg + (fun φ : ContinuousAlgHom K A (LaurentCharts.Overlap K A f) ↦ φ a) + (LaurentCharts.plusToOverlap_comp_plusMap K A f) + calc + laurentIntersectionToOverlap K A f + (plusToLaurentIntersection K A f (LaurentCharts.plusMap K A f a)) = + laurentIntersectionToOverlap K A f (laurentIntersectionMap K A f a) := + congrArg (laurentIntersectionToOverlap K A f) + (by simpa only [ContinuousAlgHom.comp_apply] using hplus) + _ = LaurentCharts.overlapMap K A f a := by + simpa only [ContinuousAlgHom.comp_apply] using hintersection + _ = LaurentCharts.plusToOverlap K A f + (LaurentCharts.plusMap K A f a) := by + simpa only [ContinuousAlgHom.comp_apply] using hoverlap.symm + · intro i + rw [Fin.eq_zero i] + simp only [ContinuousAlgHom.comp_apply, plusToLaurentIntersection, + RationalLocalization.lift_coordinate, laurentIntersectionToOverlap_T] + rfl + +@[simp] +theorem laurentIntersectionToOverlap_comp_minusToLaurentIntersection (f : A) : + (laurentIntersectionToOverlap K A f).comp + (minusToLaurentIntersection K A f) = + LaurentCharts.minusToOverlap K A f := by + apply RationalLocalization.hom_ext K A 1 f (fun _ ↦ 1) + · apply ContinuousAlgHom.ext + intro a + simp only [ContinuousAlgHom.comp_apply] + have hminus := congrArg + (fun φ : ContinuousAlgHom K A (LaurentIntersection K A f) ↦ φ a) + (minusToLaurentIntersection_comp_minusMap K A f) + have hintersection := congrArg + (fun φ : ContinuousAlgHom K A (LaurentCharts.Overlap K A f) ↦ φ a) + (laurentIntersectionToOverlap_comp_map K A f) + have hoverlap := congrArg + (fun φ : ContinuousAlgHom K A (LaurentCharts.Overlap K A f) ↦ φ a) + (LaurentCharts.minusToOverlap_comp_minusMap K A f) + calc + laurentIntersectionToOverlap K A f + (minusToLaurentIntersection K A f (LaurentCharts.minusMap K A f a)) = + laurentIntersectionToOverlap K A f (laurentIntersectionMap K A f a) := + congrArg (laurentIntersectionToOverlap K A f) + (by simpa only [ContinuousAlgHom.comp_apply] using hminus) + _ = LaurentCharts.overlapMap K A f a := by + simpa only [ContinuousAlgHom.comp_apply] using hintersection + _ = LaurentCharts.minusToOverlap K A f + (LaurentCharts.minusMap K A f a) := by + simpa only [ContinuousAlgHom.comp_apply] using hoverlap.symm + · intro i + rw [Fin.eq_zero i] + simp only [ContinuousAlgHom.comp_apply, minusToLaurentIntersection, + RationalLocalization.lift_coordinate, laurentIntersectionToOverlap_S] + symm + exact RationalLocalization.lift_coordinate K A 1 f (fun _ ↦ 1) + (LaurentCharts.overlapMap K A f) + (fun _ ↦ LaurentCharts.overlapInverse K A f) + (fun _ ↦ LaurentCharts.isPowerBounded_overlapInverse K A f) + (fun _ ↦ by simp) 0 + +private theorem overlapToLaurentIntersection_comp_intersectionToOverlap (f : A) : + (overlapToLaurentIntersection K A f).comp + (laurentIntersectionToOverlap K A f) = + ContinuousAlgHom.id K (LaurentIntersection K A f) := by + apply RationalLocalization.hom_ext K A 2 f (laurentIntersectionNumerator A f) + · apply ContinuousAlgHom.ext + intro a + simp only [ContinuousAlgHom.comp_apply, ContinuousAlgHom.id_apply] + have hforward := congrArg + (fun φ : ContinuousAlgHom K A (LaurentCharts.Overlap K A f) ↦ φ a) + (laurentIntersectionToOverlap_comp_map K A f) + rw [show laurentIntersectionToOverlap K A f + (RationalLocalization.baseMap K A 2 f + (laurentIntersectionNumerator A f) a) = + LaurentCharts.overlapMap K A f a by + simpa only [ContinuousAlgHom.comp_apply, laurentIntersectionMap] using hforward] + change + overlapToLaurentIntersection K A f + (LaurentCharts.plusToOverlap K A f + (LaurentCharts.plusMap K A f a)) = + laurentIntersectionMap K A f a + have hback := congrArg + (fun φ : ContinuousAlgHom K (LaurentCharts.Plus K A f) + (LaurentIntersection K A f) ↦ φ (LaurentCharts.plusMap K A f a)) + (overlapToLaurentIntersection_comp_plusToOverlap K A f) + rw [show overlapToLaurentIntersection K A f + (LaurentCharts.plusToOverlap K A f (LaurentCharts.plusMap K A f a)) = + plusToLaurentIntersection K A f (LaurentCharts.plusMap K A f a) by + simpa only [ContinuousAlgHom.comp_apply] using hback] + have hplus := congrArg + (fun φ : ContinuousAlgHom K A (LaurentIntersection K A f) ↦ φ a) + (plusToLaurentIntersection_comp_plusMap K A f) + simpa only [ContinuousAlgHom.comp_apply] using hplus + · intro i + by_cases hi : i = 0 + · subst i + simp only [ContinuousAlgHom.comp_apply, ContinuousAlgHom.id_apply] + rw [show laurentIntersectionToOverlap K A f + (RationalLocalization.coordinate K A 2 f + (laurentIntersectionNumerator A f) 0) = overlapT K A f by + simpa only [laurentIntersectionT] using + laurentIntersectionToOverlap_T K A f] + change + overlapToLaurentIntersection K A f + (LaurentCharts.plusToOverlap K A f + (RationalLocalization.coordinate K A 1 1 (fun _ ↦ f) 0)) = + laurentIntersectionT K A f + have hback := congrArg + (fun φ : ContinuousAlgHom K (LaurentCharts.Plus K A f) + (LaurentIntersection K A f) ↦ + φ (RationalLocalization.coordinate K A 1 1 (fun _ ↦ f) 0)) + (overlapToLaurentIntersection_comp_plusToOverlap K A f) + rw [show overlapToLaurentIntersection K A f + (LaurentCharts.plusToOverlap K A f + (RationalLocalization.coordinate K A 1 1 (fun _ ↦ f) 0)) = + plusToLaurentIntersection K A f + (RationalLocalization.coordinate K A 1 1 (fun _ ↦ f) 0) by + simpa only [ContinuousAlgHom.comp_apply] using hback] + exact RationalLocalization.lift_coordinate K A 1 1 (fun _ ↦ f) + (laurentIntersectionMap K A f) (fun _ ↦ laurentIntersectionT K A f) + (fun _ ↦ isPowerBounded_laurentIntersectionT K A f) + (fun _ ↦ by simp) 0 + · have hi1 : i = 1 := Fin.eq_one_of_ne_zero i hi + subst i + simp only [ContinuousAlgHom.comp_apply, ContinuousAlgHom.id_apply] + rw [show laurentIntersectionToOverlap K A f + (RationalLocalization.coordinate K A 2 f + (laurentIntersectionNumerator A f) 1) = + LaurentCharts.overlapInverse K A f by + simpa only [laurentIntersectionS] using + laurentIntersectionToOverlap_S K A f] + simpa only [laurentIntersectionS] using + overlapToLaurentIntersection_inverse K A f + +private theorem intersectionToOverlap_comp_overlapToLaurentIntersection (f : A) : + (laurentIntersectionToOverlap K A f).comp + (overlapToLaurentIntersection K A f) = + ContinuousAlgHom.id K (LaurentCharts.Overlap K A f) := by + apply RationalLocalization.hom_ext K (LaurentCharts.Plus K A f) 1 + (RationalLocalization.baseMap K A 1 1 (fun _ ↦ f) f) (fun _ ↦ 1) + · apply ContinuousAlgHom.ext + intro p + simp only [ContinuousAlgHom.comp_apply, ContinuousAlgHom.id_apply] + have hback := congrArg + (fun φ : ContinuousAlgHom K (LaurentCharts.Plus K A f) + (LaurentIntersection K A f) ↦ φ p) + (overlapToLaurentIntersection_comp_plusToOverlap K A f) + rw [show overlapToLaurentIntersection K A f + (RationalLocalization.baseMap K (LaurentCharts.Plus K A f) 1 + (RationalLocalization.baseMap K A 1 1 (fun _ ↦ f) f) + (fun _ ↦ 1) p) = + plusToLaurentIntersection K A f p by + simpa only [ContinuousAlgHom.comp_apply, LaurentCharts.plusToOverlap, + LaurentCharts.plusMap] using hback] + have hforward := congrArg + (fun φ : ContinuousAlgHom K (LaurentCharts.Plus K A f) + (LaurentCharts.Overlap K A f) ↦ φ p) + (laurentIntersectionToOverlap_comp_plusToLaurentIntersection K A f) + simpa only [ContinuousAlgHom.comp_apply, LaurentCharts.plusToOverlap, + LaurentCharts.plusMap] using hforward + · intro i + rw [Fin.eq_zero i] + simp only [ContinuousAlgHom.comp_apply, ContinuousAlgHom.id_apply] + rw [show overlapToLaurentIntersection K A f + (RationalLocalization.coordinate K (LaurentCharts.Plus K A f) 1 + (RationalLocalization.baseMap K A 1 1 (fun _ ↦ f) f) + (fun _ ↦ 1) 0) = laurentIntersectionS K A f by + simpa only [LaurentCharts.overlapInverse, LaurentCharts.plusMap] using + overlapToLaurentIntersection_inverse K A f] + simpa only [laurentIntersectionS, LaurentCharts.overlapInverse, + LaurentCharts.plusMap] using laurentIntersectionToOverlap_S K A f + +/-- The direct and iterated presentations of the Laurent overlap are algebraically equivalent. -/ +noncomputable def laurentIntersectionEquivOverlap (f : A) : + LaurentIntersection K A f ≃ₐ[K] LaurentCharts.Overlap K A f := + AlgEquiv.ofAlgHom + (laurentIntersectionToOverlap K A f).toAlgHom + (overlapToLaurentIntersection K A f).toAlgHom + (by + exact congrArg ContinuousAlgHom.toAlgHom + (intersectionToOverlap_comp_overlapToLaurentIntersection K A f)) + (by + exact congrArg ContinuousAlgHom.toAlgHom + (overlapToLaurentIntersection_comp_intersectionToOverlap K A f)) + +@[simp] +theorem laurentIntersectionEquivOverlap_apply (f : A) + (x : LaurentIntersection K A f) : + laurentIntersectionEquivOverlap K A f x = + laurentIntersectionToOverlap K A f x := + rfl + +theorem laurentDifference_eq_equiv_directDifference (f : A) : + LaurentCharts.difference K A f = + (laurentIntersectionEquivOverlap K A f).toLinearEquiv.toLinearMap.comp + (directDifference K A f) := by + apply LinearMap.ext + rintro ⟨p, q⟩ + simp only [LaurentCharts.difference_apply, LinearMap.comp_apply, + directDifference_apply, map_sub] + have hp := congrArg + (fun φ : ContinuousAlgHom K (LaurentCharts.Plus K A f) + (LaurentCharts.Overlap K A f) ↦ φ p) + (laurentIntersectionToOverlap_comp_plusToLaurentIntersection K A f) + have hq := congrArg + (fun φ : ContinuousAlgHom K (LaurentCharts.Minus K A f) + (LaurentCharts.Overlap K A f) ↦ φ q) + (laurentIntersectionToOverlap_comp_minusToLaurentIntersection K A f) + exact congrArg₂ (· - ·) + (by + change LaurentCharts.plusToOverlap K A f p = + laurentIntersectionToOverlap K A f + (plusToLaurentIntersection K A f p) + simpa only [ContinuousAlgHom.comp_apply] using hp.symm) + (by + change LaurentCharts.minusToOverlap K A f q = + laurentIntersectionToOverlap K A f + (minusToLaurentIntersection K A f q) + simpa only [ContinuousAlgHom.comp_apply] using hq.symm) + +/-- Tate's two-member Laurent-cover sequence with the standard iterated overlap is short exact. -/ +theorem laurentCharts_shortExact + (hA : IsAffinoidAlgebra K A) (f : A) : + Function.Injective (LaurentCharts.diagonal K A f) ∧ + Function.Exact (LaurentCharts.diagonal K A f) + (LaurentCharts.difference K A f) ∧ + Function.Surjective (LaurentCharts.difference K A f) := by + obtain ⟨hinj, hexact, hsurj⟩ := direct_shortExact K A hA f + refine ⟨hinj, ?_, ?_⟩ + · rw [laurentDifference_eq_equiv_directDifference K A f] + exact (laurentIntersectionEquivOverlap K A f).toLinearEquiv + |>.postcomp_exact_iff_exact |>.2 hexact + · rw [laurentDifference_eq_equiv_directDifference K A f] + exact + (laurentIntersectionEquivOverlap K A f).toLinearEquiv.surjective.comp hsurj + +/-- Compatible sections on the two members of a Laurent cover glue uniquely. -/ +theorem laurentCharts_existsUnique_glue + (hA : IsAffinoidAlgebra K A) (f : A) + (p : LaurentCharts.Plus K A f) (q : LaurentCharts.Minus K A f) + (hpq : LaurentCharts.plusToOverlap K A f p = + LaurentCharts.minusToOverlap K A f q) : + ∃! a : A, + LaurentCharts.plusMap K A f a = p ∧ + LaurentCharts.minusMap K A f a = q := by + have hzero : LaurentCharts.difference K A f (p, q) = 0 := by + simpa [LaurentCharts.difference_apply, sub_eq_zero] using hpq + obtain ⟨a, ha⟩ := + ((laurentCharts_shortExact K A hA f).2.1 (p, q)).mp hzero + refine ⟨a, ?_, ?_⟩ + · exact Prod.ext_iff.mp ha + · intro b hb + apply (laurentCharts_shortExact K A hA f).1 + calc + LaurentCharts.diagonal K A f b = (p, q) := Prod.ext hb.1 hb.2 + _ = LaurentCharts.diagonal K A f a := ha.symm + +end CompletedLaurent + +end Rigid diff --git a/Rigid/AffinoidSpectrum/Cech.lean b/Rigid/AffinoidSpectrum/Cech.lean new file mode 100644 index 0000000..bddd372 --- /dev/null +++ b/Rigid/AffinoidSpectrum/Cech.lean @@ -0,0 +1,92 @@ +import Rigid.AffinoidSpectrum.RationalCover +import Rigid.AffinoidSpectrum.RationalPresheaf +import Rigid.Cech.Normalized +import Rigid.Cech.Presheaf + +set_option linter.style.header false + +/-! +# Čech complexes of finite rational covers + +This file specializes the generic finite Čech construction to the rational-localization +presheaf. Exactness is kept separate from the construction: it is supplied by the Laurent-cover +and comparison arguments. +-/ + +open CategoryTheory + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain + +/-- The rational-localization presheaf, in the exact amount of generality needed by the generic +finite Čech construction. -/ +noncomputable abbrev rationalPresheaf (hA : IsAffinoidAlgebra K A) : Cech.Presheaf K where + Domain := AffinoidRationalSubdomain K A + subset U V := U.carrier ⊆ V.carrier + subset_refl _ := Set.Subset.rfl + subset_trans hWV hVU := hWV.trans hVU + inter := inter K A + inter_subset_left := inter_subset_left K A + inter_subset_right := inter_subset_right K A + subset_inter := by + intro U V W hWU hWV + rw [carrier_inter] + exact fun x hx ↦ ⟨hWU hx, hWV hx⟩ + sections U := ModuleCat.of K U.Sections + restriction h := (restriction K A hA h).toLinearMap + restriction_id U := by + simpa using congrArg (fun φ : ContinuousAlgHom K U.Sections U.Sections ↦ φ.toLinearMap) + (restriction_id K A hA U) + restriction_comp hVU hWV := by + exact congrArg (fun φ : ContinuousAlgHom K _ _ ↦ φ.toLinearMap) + (restriction_comp K A hA hVU hWV) + +namespace Cover + +/-- A rational cover, regarded as a finite family in the rational-localization presheaf. -/ +noncomputable abbrev cechFamily (hA : IsAffinoidAlgebra K A) + {U : AffinoidRationalSubdomain K A} (𝒰 : Cover K A U) : + (rationalPresheaf K A hA).Family where + ambient := U + card := 𝒰.m + domain := 𝒰.domain + subset := 𝒰.subset + +/-- The augmented unnormalized Čech complex of a finite rational cover. -/ +noncomputable def cechComplex (hA : IsAffinoidAlgebra K A) + {U : AffinoidRationalSubdomain K A} (𝒰 : Cover K A U) : + CochainComplex (ModuleCat K) ℕ := + (𝒰.cechFamily K A hA).augmentedCechComplex + +/-- Degree zero of the augmented rational Čech complex is the ring of sections on the covered +domain. -/ +noncomputable def cechComplexDegreeZeroIso (hA : IsAffinoidAlgebra K A) + {U : AffinoidRationalSubdomain K A} (𝒰 : Cover K A U) : + (𝒰.cechComplex K A hA).X 0 ≅ ModuleCat.of K U.Sections := + (𝒰.cechFamily K A hA).augmentedCechComplexDegreeZeroIso + +/-- The augmented normalized Čech complex of a finite rational cover. -/ +noncomputable def normalizedCechComplex (hA : IsAffinoidAlgebra K A) + {U : AffinoidRationalSubdomain K A} (𝒰 : Cover K A U) : + CochainComplex (ModuleCat K) ℕ := + (𝒰.cechFamily K A hA).normalizedCechComplex + +/-- Degree zero of the augmented normalized rational Čech complex is the ring of sections on the +covered domain. -/ +noncomputable def normalizedCechComplexDegreeZeroIso (hA : IsAffinoidAlgebra K A) + {U : AffinoidRationalSubdomain K A} (𝒰 : Cover K A U) : + (𝒰.normalizedCechComplex K A hA).X 0 ≅ ModuleCat.of K U.Sections := + (𝒰.cechFamily K A hA).normalizedCechComplexDegreeZeroIso + +end Cover + +end AffinoidRationalSubdomain + +end Rigid diff --git a/Rigid/AffinoidSpectrum/CechComparison.lean b/Rigid/AffinoidSpectrum/CechComparison.lean new file mode 100644 index 0000000..a3bf67a --- /dev/null +++ b/Rigid/AffinoidSpectrum/CechComparison.lean @@ -0,0 +1,171 @@ +import Rigid.AffinoidSpectrum.Cech +import Rigid.AffinoidSpectrum.CechRefinement +import Rigid.AffinoidSpectrum.CechRestriction +import Rigid.Cech.DoubleComparison +import Rigid.Cech.RefinementContracting + +set_option linter.style.header false + +/-! +# Double-Čech comparison for rational covers + +This file specializes the fully augmented double complex to two rational covers of the same +rational subdomain. Their ambient section modules are definitionally the same, so the first +column is the normalized Čech complex of the second cover. +-/ + +open CategoryTheory + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +variable (hA : IsAffinoidAlgebra K A) +variable {U : AffinoidRationalSubdomain K A} + +private theorem doubleCorner_comm (𝒰 𝒱 : Cover K A U) : + let F := 𝒰.cechFamily K A hA + let G := 𝒱.cechFamily K A hA + ModuleCat.ofHom F.normalizedAugmentation ≫ + ModuleCat.ofHom (Cech.Presheaf.Family.verticalAugmentation F G 0) = + ModuleCat.ofHom G.normalizedAugmentation ≫ + ModuleCat.ofHom (Cech.Presheaf.Family.horizontalAugmentation F G 0) := by + dsimp only + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ τ + change + (rationalPresheaf K A hA).restriction _ + ((rationalPresheaf K A hA).restriction _ s) = + (rationalPresheaf K A hA).restriction _ + ((rationalPresheaf K A hA).restriction _ s) + rw [← LinearMap.comp_apply, Cech.Presheaf.restriction_comp, + ← LinearMap.comp_apply, Cech.Presheaf.restriction_comp] + +/-- The fully augmented double Čech grid of two rational covers of the same domain. -/ +noncomputable abbrev doubleCechGrid (𝒰 𝒱 : Cover K A U) : + Cech.DoubleComplexGrid K := + let F := 𝒰.cechFamily K A hA + let G := 𝒱.cechFamily K A hA + Cech.Presheaf.Family.fullyAugmentedDoubleGrid F G + G.normalizedAugmentation + (G.normalizedAugmentedCofaceModule.differential_comp 0) + (doubleCorner_comm K A hA 𝒰 𝒱) + +/-- The first column of the rational double Čech grid is the complex of its second cover. -/ +noncomputable def doubleCechGridColumnZeroIso (𝒰 𝒱 : Cover K A U) : + (doubleCechGrid K A hA 𝒰 𝒱).column 0 ≅ + 𝒱.normalizedCechComplex K A hA := + HomologicalComplex.Hom.isoOfComponents + (fun n ↦ by + cases n <;> exact Iso.refl _) + (by + intro i j hij + simp only [ComplexShape.up_Rel] at hij + subst j + cases i <;> rfl) + +/-- Rational-cover form of the normalized double-Čech comparison theorem. -/ +theorem normalizedCechComplex_acyclic_of_double + (𝒰 𝒱 : Cover K A U) + (h𝒱 : (𝒱.normalizedCechComplex K A hA).Acyclic) + (hrow : ∀ q, + (Cech.Presheaf.Family.horizontalAugmentedCofaceModule + (𝒰.cechFamily K A hA) (𝒱.cechFamily K A hA) q).complex.Acyclic) + (hcolumn : ∀ p, + (Cech.Presheaf.Family.verticalAugmentedCofaceModule + (𝒰.cechFamily K A hA) (𝒱.cechFamily K A hA) p).complex.Acyclic) : + (𝒰.normalizedCechComplex K A hA).Acyclic := by + apply Cech.Presheaf.Family.normalizedCechComplex_acyclic_of_double + (𝒰.cechFamily K A hA) (𝒱.cechFamily K A hA) + (𝒱.cechFamily K A hA).normalizedAugmentation + ((𝒱.cechFamily K A hA).normalizedAugmentedCofaceModule.differential_comp 0) + (doubleCorner_comm K A hA 𝒰 𝒱) + · intro i + exact (h𝒱 i).of_iso (doubleCechGridColumnZeroIso K A hA 𝒰 𝒱).symm + · exact hrow + · exact hcolumn + +/-- Acyclicity descends from an acyclic refinement when all restricted columns are acyclic. -/ +theorem normalizedCechComplex_acyclic_of_refinement + (𝒰 𝒱 : Cover K A U) (r : Refinement K A 𝒱 𝒰) + (h𝒱 : (𝒱.normalizedCechComplex K A hA).Acyclic) + (hcolumn : ∀ p, + (Cech.Presheaf.Family.verticalAugmentedCofaceModule + (𝒰.cechFamily K A hA) (𝒱.cechFamily K A hA) p).complex.Acyclic) : + (𝒰.normalizedCechComplex K A hA).Acyclic := by + apply normalizedCechComplex_acyclic_of_double K A hA 𝒰 𝒱 h𝒱 + · intro q + exact (r.cechRefinement K A hA).horizontalAugmentedCofaceModule_acyclic q + · exact hcolumn + +/-- Acyclicity ascends to a refinement when all restrictions of the refined cover to coarse +tuple intersections are acyclic. -/ +theorem refinement_normalizedCechComplex_acyclic + (𝒰 𝒱 : Cover K A U) (r : Refinement K A 𝒱 𝒰) + (h𝒰 : (𝒰.normalizedCechComplex K A hA).Acyclic) + (hrow : ∀ q, + (Cech.Presheaf.Family.horizontalAugmentedCofaceModule + (𝒱.cechFamily K A hA) (𝒰.cechFamily K A hA) q).complex.Acyclic) : + (𝒱.normalizedCechComplex K A hA).Acyclic := by + apply normalizedCechComplex_acyclic_of_double K A hA 𝒱 𝒰 h𝒰 hrow + intro p + exact (r.cechRefinement K A hA).verticalAugmentedCofaceModule_acyclic p + +/-- **Čech refinement comparison.** If `𝒱` refines `𝒰` and the restriction of `𝒱` to every +nonempty tuple intersection of `𝒰` is acyclic, then `𝒰` is acyclic exactly when `𝒱` is. + +This is BGR 8.2.1, Corollary 3, in normalized-complex form. -/ +theorem normalizedCechComplex_acyclic_iff_of_refinement + (𝒰 𝒱 : Cover K A U) (r : Refinement K A 𝒱 𝒰) + (hrestrict : ∀ p (σ : (𝒰.cechFamily K A hA).StrictTuple p), + let W := (𝒰.cechFamily K A hA).tupleInter p σ + let hWU := ((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)) + ((𝒱.restrictTo K A W hWU).normalizedCechComplex K A hA).Acyclic) : + (𝒰.normalizedCechComplex K A hA).Acyclic ↔ + (𝒱.normalizedCechComplex K A hA).Acyclic := by + constructor + · intro h𝒰 + apply refinement_normalizedCechComplex_acyclic K A hA 𝒰 𝒱 r h𝒰 + intro q + have hvertical := + verticalAugmentedCofaceModule_acyclic_of_restrictTo + K A hA 𝒰 𝒱 q (hrestrict q) + intro n + exact (hvertical n).of_iso + (Cech.Presheaf.Family.verticalAugmentedCofaceModuleIso + (𝒰.cechFamily K A hA) (𝒱.cechFamily K A hA) q) + · intro h𝒱 + apply normalizedCechComplex_acyclic_of_refinement K A hA 𝒰 𝒱 r h𝒱 + intro p + exact verticalAugmentedCofaceModule_acyclic_of_restrictTo + K A hA 𝒰 𝒱 p (hrestrict p) + +/-- Covers which refine one another have equivalent normalized Čech acyclicity. The two +refinements supply contractions in the two directions of the comparison double complex. -/ +theorem normalizedCechComplex_acyclic_iff_of_mutual_refinement + (𝒰 𝒱 : Cover K A U) + (r𝒱𝒰 : Refinement K A 𝒱 𝒰) (r𝒰𝒱 : Refinement K A 𝒰 𝒱) : + (𝒰.normalizedCechComplex K A hA).Acyclic ↔ + (𝒱.normalizedCechComplex K A hA).Acyclic := by + constructor + · intro h𝒰 + apply refinement_normalizedCechComplex_acyclic K A hA 𝒰 𝒱 r𝒱𝒰 h𝒰 + intro q + exact (r𝒰𝒱.cechRefinement K A hA).horizontalAugmentedCofaceModule_acyclic q + · intro h𝒱 + apply normalizedCechComplex_acyclic_of_refinement K A hA 𝒰 𝒱 r𝒱𝒰 h𝒱 + intro p + exact (r𝒰𝒱.cechRefinement K A hA).verticalAugmentedCofaceModule_acyclic p + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/CechRebase.lean b/Rigid/AffinoidSpectrum/CechRebase.lean new file mode 100644 index 0000000..99a6ca0 --- /dev/null +++ b/Rigid/AffinoidSpectrum/CechRebase.lean @@ -0,0 +1,330 @@ +import Rigid.AffinoidSpectrum.Cech +import Rigid.AffinoidSpectrum.RationalRebase + +set_option linter.style.header false + +/-! +# Rebasing rational Čech complexes + +A rational cover of a rational subdomain `U` may be regarded as a cover of the whole spectrum of +`U.Sections`. This file identifies the tuple intersections, and then their section modules, on +the two sides. It is the chain-level form of BGR 8.2.2, Proposition 1. +-/ + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +variable (hA : IsAffinoidAlgebra K A) +variable {U : AffinoidRationalSubdomain K A} + +/-- Membership in a tuple intersection of a rebased cover is detected after applying the +canonical map to the original affinoid spectrum. -/ +theorem mem_rebase_tupleInter_carrier_iff + (𝒱 : Cover K A U) (n : ℕ) (σ : Fin (n + 1) → Fin 𝒱.m) + (y : BerkovichSpectrumOver K U.Sections) : + y ∈ (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).tupleInter n σ).carrier ↔ + ambientPoint K A U y ∈ + ((𝒱.cechFamily K A hA).tupleInter n σ).carrier := by + induction n with + | zero => + exact mem_rebase_carrier_iff K A U (𝒱.domain (σ 0)) y + | succ n ih => + rw [Cech.Presheaf.Family.tupleInter, Cech.Presheaf.Family.tupleInter, + carrier_inter, carrier_inter, Set.mem_inter_iff, Set.mem_inter_iff] + exact and_congr + (ih (fun i ↦ σ i.castSucc)) + (mem_rebase_carrier_iff K A U + (𝒱.domain (σ (Fin.last (n + 1)))) y) + +/-- The actual tuple intersection of the rebased cover and the rebase of the original tuple +intersection cut out the same rational subdomain. -/ +theorem rebase_tupleInter_carrier_eq + (𝒱 : Cover K A U) (n : ℕ) (σ : Fin (n + 1) → Fin 𝒱.m) : + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).tupleInter n σ).carrier = + (AffinoidRationalSubdomain.rebase K A U + ((𝒱.cechFamily K A hA).tupleInter n σ)).carrier := by + ext y + rw [mem_rebase_tupleInter_carrier_iff K A hA 𝒱 n σ, + mem_rebase_carrier_iff K A] + +/-- Every tuple intersection of a cover of `U` is contained in `U`. -/ +theorem tupleInter_subset_ambient + (𝒱 : Cover K A U) (n : ℕ) (σ : Fin (n + 1) → Fin 𝒱.m) : + ((𝒱.cechFamily K A hA).tupleInter n σ).carrier ⊆ U.carrier := + ((𝒱.cechFamily K A hA).tupleInter_subset_domain n σ 0).trans + ((𝒱.cechFamily K A hA).subset (σ 0)) + +/-- Sections on corresponding tuple intersections before and after rebasing are canonically +linearly equivalent. -/ +noncomputable def rebaseTupleInterSectionsLinearEquiv + (𝒱 : Cover K A U) (n : ℕ) (σ : Fin (n + 1) → Fin 𝒱.m) : + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).tupleInter n σ).Sections ≃ₗ[K] + ((𝒱.cechFamily K A hA).tupleInter n σ).Sections := + (sectionsLinearEquivOfCarrierEq K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).tupleInter n σ) + (AffinoidRationalSubdomain.rebase K A U + ((𝒱.cechFamily K A hA).tupleInter n σ)) + (rebase_tupleInter_carrier_eq K A hA 𝒱 n σ)).trans + (rebaseSectionsLinearEquiv K A hA + (tupleInter_subset_ambient K A hA 𝒱 n σ)) + +/-- The whole spectrum of `U.Sections` and the rebase of `U` itself have the same carrier. -/ +theorem whole_carrier_eq_rebase_self : + (whole K U.Sections).carrier = + (AffinoidRationalSubdomain.rebase K A U U).carrier := by + ext y + simp only [carrier_whole, Set.mem_univ, + mem_rebase_carrier_iff K A U U] + exact iff_of_true trivial (ambientPoint_mem_carrier K A U y) + +/-- The degree-zero (ambient-section) equivalence for a rebased cover. -/ +noncomputable def rebaseAmbientSectionsLinearEquiv : + (whole K U.Sections).Sections ≃ₗ[K] U.Sections := + (sectionsLinearEquivOfCarrierEq K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (whole K U.Sections) + (AffinoidRationalSubdomain.rebase K A U U) + (whole_carrier_eq_rebase_self K A)).trans + (rebaseSectionsLinearEquiv K A hA Set.Subset.rfl) + +/-- The pointwise equivalence on normalized cochains of a cover and its rebase. -/ +noncomputable def rebaseNormalizedCochainsLinearEquiv + (𝒱 : Cover K A U) (n : ℕ) : + ((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).NormalizedCochains n ≃ₗ[K] + (𝒱.cechFamily K A hA).NormalizedCochains n := + LinearEquiv.piCongrRight (R := K) fun σ ↦ + rebaseTupleInterSectionsLinearEquiv K A hA 𝒱 n σ + +/-- The same cochain equivalence as an isomorphism in `ModuleCat`, with the scalar ring fixed +explicitly so typeclass search does not inspect the dependent product for other module +structures. -/ +noncomputable def rebaseNormalizedCochainsModuleIso + (𝒱 : Cover K A U) (n : ℕ) : + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).normalizedCofaceModule.X n) ≅ + (𝒱.cechFamily K A hA).normalizedCofaceModule.X n := by + let X := ((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).normalizedCofaceModule.X n + let Y := (𝒱.cechFamily K A hA).normalizedCofaceModule.X n + letI : AddCommGroup X := X.isAddCommGroup + letI : Module K X := X.isModule + letI : AddCommGroup Y := Y.isAddCommGroup + letI : Module K Y := Y.isModule + let e₀ := rebaseNormalizedCochainsLinearEquiv K A hA 𝒱 n + let e : X ≃ₗ[K] Y := + { toFun := e₀ + invFun := e₀.symm + left_inv := e₀.left_inv + right_inv := e₀.right_inv + map_add' := e₀.map_add + map_smul' := e₀.map_smul } + exact e.toModuleIso + +/-- The component equivalences underlying the rebasing isomorphism of Čech complexes. -/ +noncomputable abbrev rebaseNormalizedCechComponentLinearEquiv + (𝒱 : Cover K A U) : + ∀ n, + ((𝒱.rebase K A).normalizedCechComplex K U.Sections + (isAffinoidAlgebra_sections K A hA U)).X n ≃ₗ[K] + (𝒱.normalizedCechComplex K A hA).X n + | 0 => rebaseAmbientSectionsLinearEquiv K A hA + | n + 1 => rebaseNormalizedCochainsLinearEquiv K A hA 𝒱 n + +noncomputable abbrev rebaseNormalizedCechComponentIso + (𝒱 : Cover K A U) : + ∀ n, + ((𝒱.rebase K A).normalizedCechComplex K U.Sections + (isAffinoidAlgebra_sections K A hA U)).X n ≅ + (𝒱.normalizedCechComplex K A hA).X n + | 0 => (rebaseAmbientSectionsLinearEquiv K A hA).toModuleIso + | n + 1 => rebaseNormalizedCochainsModuleIso K A hA 𝒱 n + +private noncomputable abbrev rebaseNormalizedAugmentation + (𝒱 : Cover K A U) : + (whole K U.Sections).Sections →ₗ[K] + ((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).NormalizedCochains 0 := + ((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).normalizedAugmentation + +private noncomputable abbrev rebaseNormalizedCoface + (𝒱 : Cover K A U) (n : ℕ) (i : Fin (n + 2)) : + ((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).NormalizedCochains n →ₗ[K] + ((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).NormalizedCochains (n + 1) := + ((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).normalizedCoface n i + +private theorem rebase_normalizedAugmentation_comm + (𝒱 : Cover K A U) : + (rebaseNormalizedCechComponentLinearEquiv K A hA 𝒱 1).toLinearMap.comp + (rebaseNormalizedAugmentation K A hA 𝒱) = + (𝒱.cechFamily K A hA).normalizedAugmentation.comp + (rebaseNormalizedCechComponentLinearEquiv K A hA 𝒱 0).toLinearMap := by + apply LinearMap.ext + intro s + funext σ + change + (rebaseTupleInterSectionsLinearEquiv K A hA 𝒱 0 σ) + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).normalizedAugmentation s σ) = + (𝒱.cechFamily K A hA).normalizedAugmentation + (rebaseAmbientSectionsLinearEquiv K A hA s) σ + change + ((rebaseToSections K A hA + (tupleInter_subset_ambient K A hA 𝒱 0 σ)).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (rebase_tupleInter_carrier_eq K A hA 𝒱 0 σ).ge)) + ((restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).subset (σ 0))) s) = + (restriction K A hA ((𝒱.cechFamily K A hA).subset (σ 0))) + (((rebaseToSections K A hA Set.Subset.rfl).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (whole_carrier_eq_rebase_self K A).ge)) s) + exact congrArg + (fun φ : ContinuousAlgHom K (whole K U.Sections).Sections + ((𝒱.cechFamily K A hA).tupleInter 0 σ).Sections ↦ φ s) + (rebaseToSections_natural_of_carrier_eq K A hA + Set.Subset.rfl + ((𝒱.cechFamily K A hA).subset (σ 0)) + (whole_carrier_eq_rebase_self K A) + (rebase_tupleInter_carrier_eq K A hA 𝒱 0 σ) + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).subset (σ 0))).symm + +private theorem rebase_normalizedCoface_comm + (𝒱 : Cover K A U) (n : ℕ) (i : Fin (n + 2)) : + (rebaseNormalizedCechComponentLinearEquiv K A hA 𝒱 + (n + 2)).toLinearMap.comp + (rebaseNormalizedCoface K A hA 𝒱 n i) = + ((𝒱.cechFamily K A hA).normalizedCoface n i).comp + (rebaseNormalizedCechComponentLinearEquiv K A hA 𝒱 + (n + 1)).toLinearMap := by + apply LinearMap.ext + intro s + funext σ + change + (rebaseTupleInterSectionsLinearEquiv K A hA 𝒱 (n + 1) σ) + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).normalizedCoface n i s σ) = + (𝒱.cechFamily K A hA).normalizedCoface n i + (rebaseNormalizedCochainsLinearEquiv K A hA 𝒱 n s) σ + change + ((rebaseToSections K A hA + (tupleInter_subset_ambient K A hA 𝒱 (n + 1) σ)).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (rebase_tupleInter_carrier_eq K A hA 𝒱 (n + 1) σ).ge)) + ((restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (Cech.Presheaf.Family.tupleInter_subset_strictDelete + ((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)) i σ)) (s _)) = + (restriction K A hA + ((𝒱.cechFamily K A hA).tupleInter_subset_strictDelete i σ) + (((rebaseToSections K A hA + (tupleInter_subset_ambient K A hA 𝒱 n + ((𝒱.cechFamily K A hA).strictDelete i σ))).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (rebase_tupleInter_carrier_eq K A hA 𝒱 n + ((𝒱.cechFamily K A hA).strictDelete i σ)).ge)) (s _))) + exact congrArg + (fun φ : ContinuousAlgHom K + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).tupleInter n + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).strictDelete i σ)).Sections + ((𝒱.cechFamily K A hA).tupleInter (n + 1) σ).Sections ↦ φ (s _)) + (rebaseToSections_natural_of_carrier_eq K A hA + (tupleInter_subset_ambient K A hA 𝒱 n + ((𝒱.cechFamily K A hA).strictDelete i σ)) + ((𝒱.cechFamily K A hA).tupleInter_subset_strictDelete i σ) + (rebase_tupleInter_carrier_eq K A hA 𝒱 n + ((𝒱.cechFamily K A hA).strictDelete i σ)) + (rebase_tupleInter_carrier_eq K A hA 𝒱 (n + 1) σ) + (Cech.Presheaf.Family.tupleInter_subset_strictDelete + ((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)) i σ)).symm + +private theorem rebase_normalizedDifferential_comm + (𝒱 : Cover K A U) (n : ℕ) : + CategoryTheory.CategoryStruct.comp + (Cech.CofaceModule.differential + (((𝒱.rebase K A).cechFamily K U.Sections + (isAffinoidAlgebra_sections K A hA U)).normalizedCofaceModule) n) + (rebaseNormalizedCochainsModuleIso K A hA 𝒱 (n + 1)).hom = + CategoryTheory.CategoryStruct.comp + (rebaseNormalizedCochainsModuleIso K A hA 𝒱 n).hom + (Cech.CofaceModule.differential + ((𝒱.cechFamily K A hA).normalizedCofaceModule) n) := by + simp only [Cech.CofaceModule.differential, + CategoryTheory.Preadditive.sum_comp, CategoryTheory.Preadditive.zsmul_comp] + rw [CategoryTheory.Preadditive.comp_sum] + simp only [CategoryTheory.Preadditive.comp_zsmul] + apply Finset.sum_congr rfl + intro k _ + congr 1 + apply ModuleCat.hom_ext + dsimp only [rebaseNormalizedCochainsModuleIso] + exact rebase_normalizedCoface_comm K A hA 𝒱 n k + +/-- The augmented normalized Čech complex of a cover is canonically isomorphic to the complex of +the same cover rebased to the whole spectrum of the ambient section algebra. -/ +noncomputable def rebaseNormalizedCechIso + (𝒱 : Cover K A U) : + (𝒱.rebase K A).normalizedCechComplex K U.Sections + (isAffinoidAlgebra_sections K A hA U) ≅ + 𝒱.normalizedCechComplex K A hA := + HomologicalComplex.Hom.isoOfComponents + (rebaseNormalizedCechComponentIso K A hA 𝒱) + (by + intro i j hij + simp only [ComplexShape.up_Rel] at hij + subst j + dsimp only [normalizedCechComplex] + cases i with + | zero => + apply ModuleCat.hom_ext + dsimp only [rebaseNormalizedCechComponentIso] + exact (rebase_normalizedAugmentation_comm K A hA 𝒱).symm + | succ n => + simpa only [Cech.CofaceModule.Augmented.complex, + CochainComplex.of_d, Cech.CofaceModule.Augmented.differential, + rebaseNormalizedCechComponentIso] using + (rebase_normalizedDifferential_comm K A hA 𝒱 n).symm) + +/-- A rational cover is acyclic exactly when its rebase to the whole spectrum of `U.Sections` +is acyclic. -/ +theorem normalizedCechComplex_acyclic_iff_rebase + (𝒱 : Cover K A U) : + (𝒱.normalizedCechComplex K A hA).Acyclic ↔ + ((𝒱.rebase K A).normalizedCechComplex K U.Sections + (isAffinoidAlgebra_sections K A hA U)).Acyclic := by + constructor + · intro h n + exact (h n).of_iso (rebaseNormalizedCechIso K A hA 𝒱).symm + · intro h n + exact (h n).of_iso (rebaseNormalizedCechIso K A hA 𝒱) + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/CechRefinement.lean b/Rigid/AffinoidSpectrum/CechRefinement.lean new file mode 100644 index 0000000..cd8d7e9 --- /dev/null +++ b/Rigid/AffinoidSpectrum/CechRefinement.lean @@ -0,0 +1,40 @@ +import Rigid.AffinoidSpectrum.Cech +import Rigid.Cech.Refinement + +set_option linter.style.header false + +/-! +# Refinement maps for rational Čech complexes + +This file connects rational-cover refinements to the generic chain-level refinement map. +-/ + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +/-- A rational-cover refinement as a refinement of the corresponding Čech families. -/ +noncomputable def Refinement.cechRefinement (hA : IsAffinoidAlgebra K A) + {U : AffinoidRationalSubdomain K A} {𝒱 𝒰 : Cover K A U} + (r : Refinement K A 𝒱 𝒰) : + (𝒱.cechFamily K A hA).Refinement (𝒰.cechFamily K A hA) where + index := r.index + subset := r.subset + +/-- Restriction of ordinary Čech cochains along a rational-cover refinement. -/ +noncomputable def Refinement.cechComplexMap (hA : IsAffinoidAlgebra K A) + {U : AffinoidRationalSubdomain K A} {𝒱 𝒰 : Cover K A U} + (r : Refinement K A 𝒱 𝒰) : + (𝒰.cechFamily K A hA).cofaceModule.complex ⟶ + (𝒱.cechFamily K A hA).cofaceModule.complex := + (r.cechRefinement K A hA).complexMap + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/CechRestriction.lean b/Rigid/AffinoidSpectrum/CechRestriction.lean new file mode 100644 index 0000000..c9e4fca --- /dev/null +++ b/Rigid/AffinoidSpectrum/CechRestriction.lean @@ -0,0 +1,270 @@ +import Rigid.AffinoidSpectrum.Cech +import Rigid.Cech.Fiber + +set_option linter.style.header false + +/-! +# Restrictions of rational covers + +Intersecting every member of a rational cover with a rational subdomain gives a rational cover +of that subdomain. Its normalized Čech complex is the fixed-subdomain fiber occurring in the +normalized double Čech complex. This is the chain-level restriction identification used in +BGR 8.2.1, Comparison Theorem 2. +-/ + +open CategoryTheory + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +/-- Restrict a rational cover to a rational subdomain of its ambient domain. -/ +noncomputable abbrev restrictTo + {U : AffinoidRationalSubdomain K A} (𝒱 : Cover K A U) + (W : AffinoidRationalSubdomain K A) (hWU : W.carrier ⊆ U.carrier) : + Cover K A W where + m := 𝒱.m + domain j := inter K A W (𝒱.domain j) + subset j := inter_subset_left K A W (𝒱.domain j) + covers := by + ext x + constructor + · intro hx + rw [𝒱.covers] at hWU + obtain ⟨j, hxj⟩ := Set.mem_iUnion.mp (hWU hx) + exact Set.mem_iUnion.mpr ⟨j, by + rw [carrier_inter] + exact ⟨hx, hxj⟩⟩ + · intro hx + obtain ⟨j, hxj⟩ := Set.mem_iUnion.mp hx + exact (by + rw [carrier_inter] at hxj + exact hxj.1) + +@[simp] +theorem restrictTo_m + {U : AffinoidRationalSubdomain K A} (𝒱 : Cover K A U) + (W : AffinoidRationalSubdomain K A) (hWU : W.carrier ⊆ U.carrier) : + (𝒱.restrictTo K A W hWU).m = 𝒱.m := + rfl + +@[simp] +theorem restrictTo_domain + {U : AffinoidRationalSubdomain K A} (𝒱 : Cover K A U) + (W : AffinoidRationalSubdomain K A) (hWU : W.carrier ⊆ U.carrier) + (j : Fin 𝒱.m) : + (𝒱.restrictTo K A W hWU).domain j = inter K A W (𝒱.domain j) := + rfl + +variable (hA : IsAffinoidAlgebra K A) +variable {U : AffinoidRationalSubdomain K A} + +/-- Tuple intersections in a restricted cover have the same carrier as intersecting the fixed +subdomain with the corresponding tuple intersection of the original cover. -/ +theorem restrictTo_tupleInter_carrier_eq + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) (n : ℕ) + (τ : (𝒱.cechFamily K A hA).StrictTuple n) : + (((𝒱.restrictTo K A W hWU).cechFamily K A hA).tupleInter n τ).carrier = + (inter K A W ((𝒱.cechFamily K A hA).tupleInter n τ)).carrier := by + induction n with + | zero => + simp only [Cech.Presheaf.Family.tupleInter] + | succ n ih => + simp only [Cech.Presheaf.Family.tupleInter, carrier_inter, + Set.ext_iff, Set.mem_inter_iff] at ih ⊢ + intro x + let τ₀ : (𝒱.cechFamily K A hA).StrictTuple n := + Fin.castSuccOrderEmb.comp τ + have hi := ih τ₀ x + change + x ∈ (((𝒱.restrictTo K A W hWU).cechFamily K A hA).tupleInter n + (fun i ↦ τ i.castSucc)).carrier ↔ + x ∈ W.carrier ∧ + x ∈ ((𝒱.cechFamily K A hA).tupleInter n + (fun i ↦ τ i.castSucc)).carrier at hi + rw [hi] + constructor + · rintro ⟨⟨hxW, hxTuple⟩, hxLast⟩ + exact ⟨hxW, hxTuple, hxLast.2⟩ + · rintro ⟨hxW, hxTuple, hxLast⟩ + exact ⟨⟨hxW, hxTuple⟩, hxW, hxLast⟩ + +/-- Sections on tuple intersections of a restricted cover are canonically equivalent to the +corresponding fixed-subdomain double-Čech fiber. -/ +noncomputable def restrictToTupleInterSectionsLinearEquiv + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) (n : ℕ) + (τ : (𝒱.restrictTo K A W hWU).cechFamily K A hA |>.StrictTuple n) : + (((𝒱.restrictTo K A W hWU).cechFamily K A hA).tupleInter n τ).Sections ≃ₗ[K] + (inter K A W ((𝒱.cechFamily K A hA).tupleInter n τ)).Sections := + sectionsLinearEquivOfCarrierEq K A hA _ _ + (restrictTo_tupleInter_carrier_eq K A hA 𝒱 W hWU n τ) + +/-- Pointwise equivalence between normalized cochains of a restricted cover and fixed-subdomain +vertical fiber cochains. -/ +noncomputable def restrictToNormalizedCochainsLinearEquiv + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) (n : ℕ) : + ((𝒱.restrictTo K A W hWU).cechFamily K A hA).NormalizedCochains n ≃ₗ[K] + (∀ τ : (𝒱.cechFamily K A hA).StrictTuple n, + (inter K A W ((𝒱.cechFamily K A hA).tupleInter n τ)).Sections) := + LinearEquiv.piCongrRight (R := K) fun τ ↦ + restrictToTupleInterSectionsLinearEquiv K A hA 𝒱 W hWU n τ + +private theorem restrictTo_normalizedAugmentation_comm + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) : + (restrictToNormalizedCochainsLinearEquiv K A hA 𝒱 W hWU 0).toLinearMap.comp + ((𝒱.restrictTo K A W hWU).cechFamily K A hA).normalizedAugmentation = + Cech.Presheaf.Family.verticalFiberAugmentation + (Cech.Presheaf.Family.singletonFamily + (P := rationalPresheaf K A hA) W) + (𝒱.cechFamily K A hA) + (Cech.Presheaf.Family.singletonStrictTuple + (P := rationalPresheaf K A hA) W) := by + apply LinearMap.ext + intro s + funext τ + change + restriction K A hA _ + (restriction K A hA _ s) = + restriction K A hA _ s + rw [← ContinuousAlgHom.comp_apply, restriction_comp] + +private theorem restrictTo_normalizedCoface_comm + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) (n : ℕ) (i : Fin (n + 2)) : + (restrictToNormalizedCochainsLinearEquiv K A hA 𝒱 W hWU + (n + 1)).toLinearMap.comp + (((𝒱.restrictTo K A W hWU).cechFamily K A hA).normalizedCoface n i) = + (Cech.Presheaf.Family.verticalFiberCoface + (Cech.Presheaf.Family.singletonFamily + (P := rationalPresheaf K A hA) W) + (𝒱.cechFamily K A hA) + (Cech.Presheaf.Family.singletonStrictTuple + (P := rationalPresheaf K A hA) W) n i).comp + (restrictToNormalizedCochainsLinearEquiv K A hA 𝒱 W hWU n).toLinearMap := by + apply LinearMap.ext + intro s + funext τ + change + restriction K A hA _ + (restriction K A hA _ (s (i.succAboveOrderEmb.comp τ))) = + restriction K A hA _ + (restriction K A hA _ (s (i.succAboveOrderEmb.comp τ))) + rw [← ContinuousAlgHom.comp_apply, restriction_comp, + ← ContinuousAlgHom.comp_apply, restriction_comp] + +/-- The normalized cochains of a restricted rational cover and the corresponding fixed-domain +fiber are isomorphic as modules. -/ +noncomputable def restrictToNormalizedCochainsModuleIso + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) (n : ℕ) : + ((𝒱.restrictTo K A W hWU).cechFamily K A hA).normalizedCofaceModule.X n ≅ + (Cech.Presheaf.Family.fixedDomainCofaceModule + (P := rationalPresheaf K A hA) W + (𝒱.cechFamily K A hA)).X n := + (restrictToNormalizedCochainsLinearEquiv K A hA 𝒱 W hWU n).toModuleIso + +private theorem restrictTo_normalizedDifferential_comm + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) (n : ℕ) : + ((𝒱.restrictTo K A W hWU).cechFamily K A hA).normalizedCofaceModule.differential n ≫ + (restrictToNormalizedCochainsModuleIso K A hA 𝒱 W hWU (n + 1)).hom = + (restrictToNormalizedCochainsModuleIso K A hA 𝒱 W hWU n).hom ≫ + (Cech.Presheaf.Family.fixedDomainCofaceModule + (P := rationalPresheaf K A hA) W + (𝒱.cechFamily K A hA)).differential n := by + simp only [Cech.CofaceModule.differential, + CategoryTheory.Preadditive.sum_comp, CategoryTheory.Preadditive.zsmul_comp] + rw [CategoryTheory.Preadditive.comp_sum] + simp only [CategoryTheory.Preadditive.comp_zsmul] + apply Finset.sum_congr rfl + intro i _ + congr 1 + apply ModuleCat.hom_ext + exact restrictTo_normalizedCoface_comm K A hA 𝒱 W hWU n i + +private noncomputable abbrev restrictToCechComponentIso + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) : + ∀ n, ( + ((𝒱.restrictTo K A W hWU).normalizedCechComplex K A hA).X n ≅ + (Cech.Presheaf.Family.fixedDomainAugmentedCofaceModule + (P := rationalPresheaf K A hA) W + (𝒱.cechFamily K A hA)).complex.X n) + | 0 => Iso.refl _ + | n + 1 => restrictToNormalizedCochainsModuleIso K A hA 𝒱 W hWU n + +/-- The normalized Čech complex of a restricted rational cover is canonically isomorphic to the +fixed-domain augmented fiber of the double Čech complex. -/ +noncomputable def restrictToNormalizedCechIso + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) : + (𝒱.restrictTo K A W hWU).normalizedCechComplex K A hA ≅ + (Cech.Presheaf.Family.fixedDomainAugmentedCofaceModule + (P := rationalPresheaf K A hA) W + (𝒱.cechFamily K A hA)).complex := + HomologicalComplex.Hom.isoOfComponents + (restrictToCechComponentIso K A hA 𝒱 W hWU) + (by + intro i j hij + simp only [ComplexShape.up_Rel] at hij + subst j + dsimp only [normalizedCechComplex] + cases i with + | zero => + apply ModuleCat.hom_ext + exact (restrictTo_normalizedAugmentation_comm K A hA 𝒱 W hWU).symm + | succ n => + simpa only [Cech.CofaceModule.Augmented.complex, + CochainComplex.of_d, Cech.CofaceModule.Augmented.differential, + restrictToCechComponentIso] using + (restrictTo_normalizedDifferential_comm K A hA 𝒱 W hWU n).symm) + +/-- A rational cover restricted to a rational subdomain is acyclic exactly when the associated +fixed-domain fiber is acyclic. -/ +theorem restrictTo_normalizedCechComplex_acyclic_iff + (𝒱 : Cover K A U) (W : AffinoidRationalSubdomain K A) + (hWU : W.carrier ⊆ U.carrier) : + ((𝒱.restrictTo K A W hWU).normalizedCechComplex K A hA).Acyclic ↔ + (Cech.Presheaf.Family.fixedDomainAugmentedCofaceModule + (P := rationalPresheaf K A hA) W + (𝒱.cechFamily K A hA)).complex.Acyclic := by + constructor + · intro h n + exact (h n).of_iso (restrictToNormalizedCechIso K A hA 𝒱 W hWU) + · intro h n + exact (h n).of_iso (restrictToNormalizedCechIso K A hA 𝒱 W hWU).symm + +/-- If all restrictions of `𝒱` to the tuple intersections of `𝒰` are acyclic, then every +vertical column of the double Čech complex is acyclic. -/ +theorem verticalAugmentedCofaceModule_acyclic_of_restrictTo + (𝒰 𝒱 : Cover K A U) (p : ℕ) + (hrestrict : ∀ σ : (𝒰.cechFamily K A hA).StrictTuple p, + let W := (𝒰.cechFamily K A hA).tupleInter p σ + let hWU := ((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)) + ((𝒱.restrictTo K A W hWU).normalizedCechComplex K A hA).Acyclic) : + (Cech.Presheaf.Family.verticalAugmentedCofaceModule + (𝒰.cechFamily K A hA) (𝒱.cechFamily K A hA) p).complex.Acyclic := by + apply Cech.Presheaf.Family.verticalAugmentedCofaceModule_acyclic_of_fibers + intro σ + let W := (𝒰.cechFamily K A hA).tupleInter p σ + let hWU := ((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)) + have hfixed := + (restrictTo_normalizedCechComplex_acyclic_iff K A hA 𝒱 W hWU).1 + (hrestrict σ) + exact hfixed + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/CoverProduct.lean b/Rigid/AffinoidSpectrum/CoverProduct.lean new file mode 100644 index 0000000..18391d4 --- /dev/null +++ b/Rigid/AffinoidSpectrum/CoverProduct.lean @@ -0,0 +1,182 @@ +import Rigid.AffinoidSpectrum.CechComparison + +set_option linter.style.header false + +/-! +# Products of finite rational covers + +The product of two covers consists of all pairwise intersections. Restricting such a product +to a tuple intersection of the first cover gives a cover mutually refining the corresponding +restriction of the second cover. Together with Čech comparison this proves BGR 8.1.4, +Corollary 4. +-/ + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +variable {U : AffinoidRationalSubdomain K A} + +/-- The finite index type used for the product of two covers. -/ +abbrev ProductIndex (𝒰 𝒱 : Cover K A U) := + Fin 𝒰.m × Fin 𝒱.m + +/-- Decode the finite index of a product cover into its two components. -/ +noncomputable def productPair (𝒰 𝒱 : Cover K A U) : + Fin (𝒰.m * 𝒱.m) → ProductIndex K A 𝒰 𝒱 := + finProdFinEquiv.symm + +/-- Encode a pair of cover indices as an index of the product cover. -/ +noncomputable def productIndex (𝒰 𝒱 : Cover K A U) : + ProductIndex K A 𝒰 𝒱 → Fin (𝒰.m * 𝒱.m) := + finProdFinEquiv + +@[simp] +theorem productPair_productIndex (𝒰 𝒱 : Cover K A U) + (ij : ProductIndex K A 𝒰 𝒱) : + productPair K A 𝒰 𝒱 (productIndex K A 𝒰 𝒱 ij) = ij := + finProdFinEquiv.symm_apply_apply ij + +@[simp] +theorem productIndex_productPair (𝒰 𝒱 : Cover K A U) + (k : Fin (𝒰.m * 𝒱.m)) : + productIndex K A 𝒰 𝒱 (productPair K A 𝒰 𝒱 k) = k := + finProdFinEquiv.apply_symm_apply k + +/-- The product cover consisting of all intersections `Uᵢ ∩ Vⱼ`. -/ +noncomputable abbrev product (𝒰 𝒱 : Cover K A U) : Cover K A U where + m := 𝒰.m * 𝒱.m + domain k := + inter K A + (𝒰.domain (productPair K A 𝒰 𝒱 k).1) + (𝒱.domain (productPair K A 𝒰 𝒱 k).2) + subset k := + (inter_subset_left K A _ _).trans + (𝒰.subset (productPair K A 𝒰 𝒱 k).1) + covers := by + apply Set.Subset.antisymm + · intro x hx + rw [𝒰.covers] at hx + obtain ⟨i, hxi⟩ := Set.mem_iUnion.mp hx + have hxU : x ∈ U.carrier := 𝒰.subset i hxi + rw [𝒱.covers] at hxU + obtain ⟨j, hxj⟩ := Set.mem_iUnion.mp hxU + refine Set.mem_iUnion.mpr + ⟨productIndex K A 𝒰 𝒱 (i, j), ?_⟩ + rw [carrier_inter, productPair_productIndex] + exact ⟨hxi, hxj⟩ + · intro x hx + obtain ⟨k, hxk⟩ := Set.mem_iUnion.mp hx + exact (inter_subset_left K A _ _) hxk |> 𝒰.subset _ + +/-- The product cover refines its left factor. -/ +noncomputable def productRefinementLeft (𝒰 𝒱 : Cover K A U) : + Refinement K A (product K A 𝒰 𝒱) 𝒰 where + index k := (productPair K A 𝒰 𝒱 k).1 + subset k := inter_subset_left K A + (𝒰.domain (productPair K A 𝒰 𝒱 k).1) + (𝒱.domain (productPair K A 𝒰 𝒱 k).2) + +/-- The product cover refines its right factor. -/ +noncomputable def productRefinementRight (𝒰 𝒱 : Cover K A U) : + Refinement K A (product K A 𝒰 𝒱) 𝒱 where + index k := (productPair K A 𝒰 𝒱 k).2 + subset k := inter_subset_right K A + (𝒰.domain (productPair K A 𝒰 𝒱 k).1) + (𝒱.domain (productPair K A 𝒰 𝒱 k).2) + +variable (hA : IsAffinoidAlgebra K A) + +private noncomputable def restrictedProductRefinementRight + (𝒰 𝒱 : Cover K A U) (p : ℕ) + (σ : (𝒰.cechFamily K A hA).StrictTuple p) : + let W := (𝒰.cechFamily K A hA).tupleInter p σ + let hWU := ((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)) + Refinement K A + ((product K A 𝒰 𝒱).restrictTo K A W hWU) + (𝒱.restrictTo K A W hWU) := by + dsimp only + let W := (𝒰.cechFamily K A hA).tupleInter p σ + let hWU := ((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)) + exact + { index := fun k ↦ (productPair K A 𝒰 𝒱 k).2 + subset := by + intro k x hx + rw [carrier_inter] at hx ⊢ + exact ⟨hx.1, (inter_subset_right K A _ _) hx.2⟩ } + +private noncomputable def restrictedRightRefinementProduct + (𝒰 𝒱 : Cover K A U) (p : ℕ) + (σ : (𝒰.cechFamily K A hA).StrictTuple p) : + let W := (𝒰.cechFamily K A hA).tupleInter p σ + let hWU := ((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)) + Refinement K A + (𝒱.restrictTo K A W hWU) + ((product K A 𝒰 𝒱).restrictTo K A W hWU) := by + dsimp only + let W := (𝒰.cechFamily K A hA).tupleInter p σ + let hWU := ((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)) + let owner : Fin 𝒰.m := σ 0 + exact + { index := fun j ↦ productIndex K A 𝒰 𝒱 (owner, j) + subset := by + intro j x hx + rw [carrier_inter] at hx ⊢ + rw [carrier_inter, productPair_productIndex] + have hxowner : + x ∈ (𝒰.domain owner).carrier := + (𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0 hx.1 + exact ⟨hx.1, hxowner, hx.2⟩ } + +/-- **Product-cover comparison.** If the restriction of `𝒱` to every tuple intersection of +`𝒰` is acyclic, then the product cover `𝒰 × 𝒱` is acyclic exactly when `𝒰` is. + +This is BGR 8.1.4, Corollary 4. -/ +theorem product_normalizedCechComplex_acyclic_iff_left + (𝒰 𝒱 : Cover K A U) + (hrestrict : ∀ p (σ : (𝒰.cechFamily K A hA).StrictTuple p), + let W := (𝒰.cechFamily K A hA).tupleInter p σ + let hWU := ((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)) + ((𝒱.restrictTo K A W hWU).normalizedCechComplex K A hA).Acyclic) : + ((product K A 𝒰 𝒱).normalizedCechComplex K A hA).Acyclic ↔ + (𝒰.normalizedCechComplex K A hA).Acyclic := by + have hproductRestrict : + ∀ p (σ : (𝒰.cechFamily K A hA).StrictTuple p), + let W := (𝒰.cechFamily K A hA).tupleInter p σ + let hWU := ((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)) + (((product K A 𝒰 𝒱).restrictTo K A W hWU).normalizedCechComplex + K A hA).Acyclic := by + intro p σ + exact + (normalizedCechComplex_acyclic_iff_of_mutual_refinement K A hA + (𝒱.restrictTo K A + ((𝒰.cechFamily K A hA).tupleInter p σ) + (((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)))) + ((product K A 𝒰 𝒱).restrictTo K A + ((𝒰.cechFamily K A hA).tupleInter p σ) + (((𝒰.cechFamily K A hA).tupleInter_subset_domain p σ 0).trans + ((𝒰.cechFamily K A hA).subset (σ 0)))) + (restrictedProductRefinementRight K A hA 𝒰 𝒱 p σ) + (restrictedRightRefinementProduct K A hA 𝒰 𝒱 p σ)).1 + (hrestrict p σ) + exact + (normalizedCechComplex_acyclic_iff_of_refinement K A hA + 𝒰 (product K A 𝒰 𝒱) (productRefinementLeft K A 𝒰 𝒱) + hproductRestrict).symm + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/DominatingCover.lean b/Rigid/AffinoidSpectrum/DominatingCover.lean new file mode 100644 index 0000000..6ac3c36 --- /dev/null +++ b/Rigid/AffinoidSpectrum/DominatingCover.lean @@ -0,0 +1,322 @@ +import Rigid.AffinoidSpectrum.GeneratedRestriction +import Rigid.AffinoidSpectrum.RationalRefinement +import Rigid.Berkovich.Unit + +set_option linter.style.header false + +/-! +# Čech acyclicity for dominating-family covers + +A pointwise dominating subfamily of a finite unit-ideal family itself spans +the unit ideal. Its standard generated cover has exactly the same rational +domains as the associated dominating-family cover. This connects the BGR +product refinement of an arbitrary rational cover to generated-cover +acyclicity. +-/ + +open scoped BigOperators + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +private theorem sections_subsingleton_of_subsingleton [Subsingleton A] + (V : AffinoidRationalSubdomain K A) : Subsingleton V.Sections := by + apply subsingleton_of_zero_eq_one + have h := congrArg + (RationalLocalization.baseMap K A V.n V.g V.f) + (Subsingleton.elim (0 : A) 1) + simpa using h + +/-- If the affinoid algebra is the zero ring, every term of every rational +Čech complex is zero. -/ +theorem normalizedCechComplex_acyclic_of_subsingleton [Subsingleton A] + (hA : IsAffinoidAlgebra K A) + {U : AffinoidRationalSubdomain K A} (𝒰 : Cover K A U) : + (𝒰.normalizedCechComplex K A hA).Acyclic := by + intro n + apply HomologicalComplex.ExactAt.of_isZero + cases n with + | zero => + change CategoryTheory.Limits.IsZero (ModuleCat.of K U.Sections) + letI : Subsingleton U.Sections := + sections_subsingleton_of_subsingleton K A U + exact ModuleCat.isZero_of_subsingleton _ + | succ n => + change CategoryTheory.Limits.IsZero + (ModuleCat.of K ((𝒰.cechFamily K A hA).NormalizedCochains n)) + letI : Subsingleton ((𝒰.cechFamily K A hA).NormalizedCochains n) := + ⟨fun x y ↦ funext fun σ ↦ + @Subsingleton.elim _ + (sections_subsingleton_of_subsingleton K A + ((𝒰.cechFamily K A hA).tupleInter n σ)) (x σ) (y σ)⟩ + exact ModuleCat.isZero_of_subsingleton _ + +private def denominatorFamily {r s : ℕ} (p : Fin r → A) + (denominator : Fin s → Fin r) : Fin s → A := + fun i ↦ p (denominator i) + +/-- A pointwise dominating subfamily of a finite unit-ideal family also +spans the unit ideal. -/ +theorem span_range_denominatorFamily_eq_top {r s : ℕ} (p : Fin r → A) + (hp : Ideal.span (Set.range p) = ⊤) (denominator : Fin s → Fin r) + (hdom : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin s, ∀ j : Fin r, x (p j) ≤ x (p (denominator i))) : + Ideal.span (Set.range (denominatorFamily A p denominator)) = ⊤ := by + by_contra htop + obtain ⟨m, hm, hle⟩ := + (Ideal.span (Set.range (denominatorFamily A p denominator)) + ).exists_le_maximal htop + letI : m.IsMaximal := hm + letI : IsClosed (m : Set A) := Ideal.IsMaximal.isClosed + let quotientMap : ContinuousAlgHom K A (A ⧸ m) := + { toAlgHom := Ideal.Quotient.mkₐ K m + cont := continuous_quot_mk } + let y : BerkovichSpectrumOver K (A ⧸ m) := + Classical.choice (BerkovichSpectrumOver.nonempty_of_nontrivial K (A ⧸ m)) + let x : BerkovichSpectrumOver K A := + BerkovichSpectrumOver.comapContinuous K A quotientMap y + obtain ⟨i, hi⟩ := hdom x + have hden_mem : p (denominator i) ∈ m := by + apply hle + apply Ideal.subset_span + exact ⟨i, rfl⟩ + have hden_quotient : quotientMap (p (denominator i)) = 0 := + Ideal.Quotient.eq_zero_iff_mem.mpr hden_mem + have hden_zero : x (p (denominator i)) = 0 := by + simp [x, hden_quotient] + have hp_zero (j : Fin r) : x (p j) = 0 := by + apply le_antisymm + · simpa only [hden_zero] using hi j + · exact BerkovichSpectrumOver.nonneg K A x (p j) + have hone : (1 : A) ∈ Ideal.span (Set.range p) := by + rw [hp] + exact Submodule.mem_top + obtain ⟨a, ha⟩ := Ideal.mem_span_range_iff_exists_fun.mp hone + have hterm (j : Fin r) : x (a j * p j) = 0 := by + rw [BerkovichSpectrumOver.map_mul, hp_zero, mul_zero] + have hsum : x (∑ j, a j * p j) = 0 := by + classical + let t : Finset (Fin r) := Finset.univ + change x (∑ j ∈ t, a j * p j) = 0 + induction t using Finset.induction_on with + | empty => simp + | @insert j t hj ih => + rw [Finset.sum_insert hj] + apply le_antisymm + · exact (BerkovichSpectrum.map_add_le_max x.toBerkovichSpectrum + (a j * p j) (∑ k ∈ t, a k * p k)).trans + (by rw [hterm, ih, max_self]) + · exact BerkovichSpectrumOver.nonneg K A x _ + rw [ha, BerkovichSpectrumOver.map_one] at hsum + exact one_ne_zero hsum + +private noncomputable abbrev generatedDenominatorCover {r s : ℕ} + (p : Fin r → A) (hp : Ideal.span (Set.range p) = ⊤) + (denominator : Fin s → Fin r) + (hdom : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin s, ∀ j : Fin r, x (p j) ≤ x (p (denominator i))) : + Cover K A (whole K A) := + generated K A (denominatorFamily A p denominator) + (span_range_denominatorFamily_eq_top K A p hp denominator hdom) + +private theorem dominatingDomain_carrier_eq_generatedDenominatorDomain + {r s : ℕ} (p : Fin r → A) (hp : Ideal.span (Set.range p) = ⊤) + (denominator : Fin s → Fin r) + (hdom : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin s, ∀ j : Fin r, x (p j) ≤ x (p (denominator i))) + (i : Fin s) : + (dominatingDomain K A p hp denominator i).carrier = + (generatedDomain K A (denominatorFamily A p denominator) + (span_range_denominatorFamily_eq_top K A p hp denominator hdom) i).carrier := by + ext x + rw [mem_dominatingDomain_carrier, mem_generatedDomain_carrier] + constructor + · intro h j + exact h (denominator j) + · intro h j + obtain ⟨owner, howner⟩ := hdom x + exact (howner j).trans (h owner) + +private noncomputable def dominatingRefinementGeneratedDenominator + {r s : ℕ} (p : Fin r → A) (hp : Ideal.span (Set.range p) = ⊤) + (denominator : Fin s → Fin r) + (hdom : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin s, ∀ j : Fin r, x (p j) ≤ x (p (denominator i))) : + Refinement K A + (ofDominatingFamily K A p hp denominator hdom) + (generatedDenominatorCover K A p hp denominator hdom) where + index i := i + subset i := by + change Fin s at i + exact + (dominatingDomain_carrier_eq_generatedDenominatorDomain + K A p hp denominator hdom i).le + +private noncomputable def generatedDenominatorRefinementDominating + {r s : ℕ} (p : Fin r → A) (hp : Ideal.span (Set.range p) = ⊤) + (denominator : Fin s → Fin r) + (hdom : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin s, ∀ j : Fin r, x (p j) ≤ x (p (denominator i))) : + Refinement K A + (generatedDenominatorCover K A p hp denominator hdom) + (ofDominatingFamily K A p hp denominator hdom) where + index i := i + subset i := by + change Fin s at i + exact + (dominatingDomain_carrier_eq_generatedDenominatorDomain + K A p hp denominator hdom i).ge + +private noncomputable def restrictRefinement + {U : AffinoidRationalSubdomain K A} {𝒱 𝒰 : Cover K A U} + (r : Refinement K A 𝒱 𝒰) + (W : AffinoidRationalSubdomain K A) (hWU : W.carrier ⊆ U.carrier) : + Refinement K A + (𝒱.restrictTo K A W hWU) + (𝒰.restrictTo K A W hWU) where + index := r.index + subset i x hx := by + rw [carrier_inter] at hx ⊢ + exact ⟨hx.1, r.subset i hx.2⟩ + +/-- A pointwise dominating-family cover is Čech-acyclic. -/ +theorem ofDominatingFamily_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) {r s : ℕ} + (p : Fin r → A) (hp : Ideal.span (Set.range p) = ⊤) + (denominator : Fin s → Fin r) + (hdom : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin s, ∀ j : Fin r, x (p j) ≤ x (p (denominator i))) : + ((ofDominatingFamily K A p hp denominator hdom + ).normalizedCechComplex K A hA).Acyclic := by + by_cases hnontrivial : Nontrivial A + · letI : Nontrivial A := hnontrivial + let x : BerkovichSpectrumOver K A := + Classical.choice (BerkovichSpectrumOver.nonempty_of_nontrivial K A) + obtain ⟨i, -⟩ := hdom x + let hr : Nonempty (Fin s) := ⟨i⟩ + exact + (normalizedCechComplex_acyclic_iff_of_mutual_refinement K A hA + (ofDominatingFamily K A p hp denominator hdom) + (generatedDenominatorCover K A p hp denominator hdom) + (generatedDenominatorRefinementDominating K A p hp denominator hdom) + (dominatingRefinementGeneratedDenominator K A p hp denominator hdom)).2 + (generated_normalizedCechComplex_acyclic K A hA + (denominatorFamily A p denominator) + (span_range_denominatorFamily_eq_top K A p hp denominator hdom) hr) + · letI : Subsingleton A := not_nontrivial_iff_subsingleton.mp hnontrivial + exact normalizedCechComplex_acyclic_of_subsingleton K A hA _ + +/-- A dominating-family cover remains acyclic after restriction to every +rational subdomain. -/ +theorem restrictTo_ofDominatingFamily_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) {r s : ℕ} + (p : Fin r → A) (hp : Ideal.span (Set.range p) = ⊤) + (denominator : Fin s → Fin r) + (hdom : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin s, ∀ j : Fin r, x (p j) ≤ x (p (denominator i))) + (W : AffinoidRationalSubdomain K A) : + (((ofDominatingFamily K A p hp denominator hdom).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier) + ).normalizedCechComplex K A hA).Acyclic := by + by_cases hnontrivial : Nontrivial A + · letI : Nontrivial A := hnontrivial + let x : BerkovichSpectrumOver K A := + Classical.choice (BerkovichSpectrumOver.nonempty_of_nontrivial K A) + obtain ⟨i, -⟩ := hdom x + let hr : Nonempty (Fin s) := ⟨i⟩ + let hW : W.carrier ⊆ (whole K A).carrier := by + simpa only [carrier_whole] using Set.subset_univ W.carrier + exact + (normalizedCechComplex_acyclic_iff_of_mutual_refinement K A hA + ((ofDominatingFamily K A p hp denominator hdom).restrictTo K A W hW) + ((generatedDenominatorCover K A p hp denominator hdom).restrictTo K A W hW) + (restrictRefinement K A + (generatedDenominatorRefinementDominating K A p hp denominator hdom) + W hW) + (restrictRefinement K A + (dominatingRefinementGeneratedDenominator K A p hp denominator hdom) + W hW)).2 + (restrictTo_generated_normalizedCechComplex_acyclic K A hA W + (denominatorFamily A p denominator) + (span_range_denominatorFamily_eq_top K A p hp denominator hdom) hr) + · letI : Subsingleton A := not_nontrivial_iff_subsingleton.mp hnontrivial + exact normalizedCechComplex_acyclic_of_subsingleton K A hA _ + +private theorem productFamily_globally_dominated + (𝒰 : Cover K A (whole K A)) + (x : BerkovichSpectrumOver K A) : + ∃ i : Fin (Fintype.card (DenominatorChoice K A 𝒰)), + ∀ j : Fin (Fintype.card (ProductChoice K A 𝒰)), + x (productFamily K A 𝒰 j) ≤ + x (productFamily K A 𝒰 (denominatorIndex K A 𝒰 i)) := by + apply productFamily_dominated_by_denominator K A 𝒰 x + rw [carrier_whole] + exact Set.mem_univ x + +private noncomputable abbrev productDominatingCover + (𝒰 : Cover K A (whole K A)) : Cover K A (whole K A) := + ofDominatingFamily K A (productFamily K A 𝒰) + (span_range_productFamily_eq_top K A 𝒰) + (denominatorIndex K A 𝒰) + (productFamily_globally_dominated K A 𝒰) + +private noncomputable def productCoverRefinementProductDominating + (𝒰 : Cover K A (whole K A)) : + Refinement K A (productCover K A 𝒰) (productDominatingCover K A 𝒰) where + index i := i + subset i := Set.Subset.rfl + +private noncomputable def productDominatingRefinementProductCover + (𝒰 : Cover K A (whole K A)) : + Refinement K A (productDominatingCover K A 𝒰) (productCover K A 𝒰) where + index i := i + subset i := Set.Subset.rfl + +/-- The BGR product refinement of a cover of the whole spectrum is +Čech-acyclic. -/ +theorem productCover_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) (𝒰 : Cover K A (whole K A)) : + ((productCover K A 𝒰).normalizedCechComplex K A hA).Acyclic := by + exact + (normalizedCechComplex_acyclic_iff_of_mutual_refinement K A hA + (productCover K A 𝒰) (productDominatingCover K A 𝒰) + (productDominatingRefinementProductCover K A 𝒰) + (productCoverRefinementProductDominating K A 𝒰)).2 + (ofDominatingFamily_normalizedCechComplex_acyclic K A hA + (productFamily K A 𝒰) (span_range_productFamily_eq_top K A 𝒰) + (denominatorIndex K A 𝒰) + (productFamily_globally_dominated K A 𝒰)) + +/-- The BGR product refinement of a cover of the whole spectrum remains +acyclic after restriction to every rational subdomain. -/ +theorem restrictTo_productCover_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) (𝒰 : Cover K A (whole K A)) + (W : AffinoidRationalSubdomain K A) : + (((productCover K A 𝒰).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier) + ).normalizedCechComplex K A hA).Acyclic := by + let hW : W.carrier ⊆ (whole K A).carrier := by + simpa only [carrier_whole] using Set.subset_univ W.carrier + exact + (normalizedCechComplex_acyclic_iff_of_mutual_refinement K A hA + ((productCover K A 𝒰).restrictTo K A W hW) + ((productDominatingCover K A 𝒰).restrictTo K A W hW) + (restrictRefinement K A + (productDominatingRefinementProductCover K A 𝒰) W hW) + (restrictRefinement K A + (productCoverRefinementProductDominating K A 𝒰) W hW)).2 + (restrictTo_ofDominatingFamily_normalizedCechComplex_acyclic K A hA + (productFamily K A 𝒰) (span_range_productFamily_eq_top K A 𝒰) + (denominatorIndex K A 𝒰) + (productFamily_globally_dominated K A 𝒰) W) + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/GeneratedCoverReduction.lean b/Rigid/AffinoidSpectrum/GeneratedCoverReduction.lean new file mode 100644 index 0000000..0ec9a86 --- /dev/null +++ b/Rigid/AffinoidSpectrum/GeneratedCoverReduction.lean @@ -0,0 +1,762 @@ +import Rigid.AffinoidSpectrum.UnitGeneratedCover + +set_option linter.style.header false + +/-! +# Reduction of generated rational covers to unit-generated covers + +This file formalizes BGR 8.2.2, Lemma 3. A common scalar makes a finite +unit-ideal family pointwise large somewhere. On every chart of the Laurent +cover generated by the scaled family, the restricted rational cover is +equivalent to one generated by units. +-/ + +open scoped BigOperators + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +private def scaledFamily {r : ℕ} (c : K) (q : Fin r → A) : Fin r → A := + fun i ↦ algebraMap K A c * q i + +@[simp] +private theorem apply_scaledFamily {r : ℕ} (c : K) (q : Fin r → A) + (i : Fin r) (x : BerkovichSpectrumOver K A) : + x (scaledFamily K A c q i) = ‖c‖ * x (q i) := by + simp [scaledFamily] + +private theorem scaledFamily_le_scaledFamily_iff {r : ℕ} {c : K} + (hc : 0 < ‖c‖) (q : Fin r → A) (i j : Fin r) + (x : BerkovichSpectrumOver K A) : + x (scaledFamily K A c q i) ≤ x (scaledFamily K A c q j) ↔ + x (q i) ≤ x (q j) := by + simp only [apply_scaledFamily] + exact mul_le_mul_iff_right₀ hc + +/-- A finite family spanning the unit ideal can be scaled so that at every +Berkovich point at least one member has value strictly greater than one. -/ +private theorem exists_scalingConstant {r : ℕ} (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (hr : Nonempty (Fin r)) : + ∃ c : K, 0 < ‖c‖ ∧ + ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i) := by + have hmem : (1 : A) ∈ Ideal.span (Set.range q) := by + rw [hq] + exact Submodule.mem_top + obtain ⟨a, ha⟩ := + Ideal.mem_span_range_iff_exists_fun.mp hmem + letI : Nonempty (Fin r) := hr + obtain ⟨imax, himax⟩ := Finite.exists_max (fun i : Fin r ↦ ‖a i‖) + obtain ⟨c, hc⟩ := NormedField.exists_lt_norm K ‖a imax‖ + have hcpos : 0 < ‖c‖ := + (norm_nonneg (a imax)).trans_lt hc + refine ⟨c, hcpos, fun x ↦ ?_⟩ + by_contra hlarge + push Not at hlarge + have hterm (i : Fin r) : x (a i * q i) < 1 := by + by_cases hqi : x (q i) = 0 + · rw [BerkovichSpectrumOver.map_mul, hqi, mul_zero] + exact zero_lt_one + · have hqipos : 0 < x (q i) := + lt_of_le_of_ne (BerkovichSpectrumOver.nonneg K A x (q i)) (Ne.symm hqi) + calc + x (a i * q i) = x (a i) * x (q i) := by + rw [BerkovichSpectrumOver.map_mul] + _ ≤ ‖a i‖ * x (q i) := + mul_le_mul_of_nonneg_right (BerkovichSpectrumOver.le_norm K A x (a i)) + hqipos.le + _ < ‖c‖ * x (q i) := + mul_lt_mul_of_pos_right ((himax i).trans_lt hc) hqipos + _ = x (scaledFamily K A c q i) := by + rw [apply_scaledFamily] + _ ≤ 1 := hlarge i + have hsum : x (∑ i, a i * q i) < 1 := by + classical + let s : Finset (Fin r) := Finset.univ + change x (∑ i ∈ s, a i * q i) < 1 + induction s using Finset.induction_on with + | empty => simp + | @insert i s hi ih => + rw [Finset.sum_insert hi] + exact (BerkovichSpectrum.map_add_le_max x.toBerkovichSpectrum + (a i * q i) (∑ j ∈ s, a j * q j)).trans_lt + (max_lt (hterm i) ih) + rw [ha, BerkovichSpectrumOver.map_one] at hsum + exact (lt_irrefl 1) hsum + +private noncomputable def scaledFamilyList {r : ℕ} (c : K) (q : Fin r → A) : + List A := + List.ofFn (scaledFamily K A c q) + +private theorem scaledFamily_mem_list {r : ℕ} (c : K) (q : Fin r → A) + (i : Fin r) : + scaledFamily K A c q i ∈ scaledFamilyList K A c q := by + rw [scaledFamilyList, List.mem_ofFn'] + exact ⟨i, rfl⟩ + +private noncomputable def scaledLaurentCover {r : ℕ} (c : K) (q : Fin r → A) : + Cover K A (whole K A) := + laurentProduct K A 1 (scaledFamilyList K A c q) + +private def IsGESign {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) : Prop := + ∀ x ∈ ((scaledLaurentCover K A c q).domain k).carrier, + 1 ≤ x (scaledFamily K A c q i) + +private def IsLESign {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) : Prop := + ∀ x ∈ ((scaledLaurentCover K A c q).domain k).carrier, + x (scaledFamily K A c q i) ≤ 1 + +private theorem le_or_ge_sign {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) : + IsLESign K A c q k i ∨ IsGESign K A c q k i := + laurentProduct_domain_sign_of_mem K A 1 + (scaledFamilyList K A c q) (scaledFamily K A c q i) + (Or.inr (scaledFamily_mem_list K A c q i)) k + +private theorem le_sign_of_not_ge {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) + (hi : ¬ IsGESign K A c q k i) : + IsLESign K A c q k i := + (le_or_ge_sign K A c q k i).resolve_right hi + +private theorem exists_ge_sign {r : ℕ} (c : K) (q : Fin r → A) + (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) : + ∃ i : Fin r, IsGESign K A c q k i := by + by_cases hchart : + ((scaledLaurentCover K A c q).domain k).carrier.Nonempty + · obtain ⟨x, hx⟩ := hchart + obtain ⟨i, hi⟩ := hlarge x + refine ⟨i, ?_⟩ + rcases le_or_ge_sign K A c q k i with hle | hge + · exact False.elim (not_lt_of_ge (hle x hx) hi) + · exact hge + · let i : Fin r := Classical.choice hr + exact ⟨i, fun x hx ↦ False.elim (hchart ⟨x, hx⟩)⟩ + +private noncomputable abbrev chartBaseMap {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) : + ContinuousAlgHom K A ((scaledLaurentCover K A c q).domain k).Sections := + RationalLocalization.baseMap K A + ((scaledLaurentCover K A c q).domain k).n + ((scaledLaurentCover K A c q).domain k).g + ((scaledLaurentCover K A c q).domain k).f + +/-- Replace the scaled generators with value at most one on a Laurent chart +by `1`. The remaining generators become units on the chart. -/ +private noncomputable def localUnitFamily {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) : + Fin r → ((scaledLaurentCover K A c q).domain k).Sections := by + classical + exact fun i ↦ if IsGESign K A c q k i then + chartBaseMap K A c q k (scaledFamily K A c q i) + else 1 + +private theorem localUnitFamily_isUnit {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) : + IsUnit (localUnitFamily K A c q k i) := by + by_cases hi : IsGESign K A c q k i + · rw [localUnitFamily, if_pos hi] + rw [BerkovichSpectrumOver.isUnit_iff_forall_apply_ne_zero K + ((scaledLaurentCover K A c q).domain k).Sections] + intro y + have hval := hi (ambientPoint K A + ((scaledLaurentCover K A c q).domain k) y) + (ambientPoint_mem_carrier K A + ((scaledLaurentCover K A c q).domain k) y) + rw [ambientPoint_apply K A ((scaledLaurentCover K A c q).domain k)] at hval + exact ne_of_gt (zero_lt_one.trans_le hval) + · rw [localUnitFamily, if_neg hi] + exact isUnit_one + +private theorem localUnitFamily_span_top {r : ℕ} {c : K} (hc : c ≠ 0) + (q : Fin r → A) (hq : Ideal.span (Set.range q) = ⊤) + (k : Fin (scaledLaurentCover K A c q).m) : + Ideal.span (Set.range (localUnitFamily K A c q k)) = ⊤ := by + classical + by_cases hall : ∀ i, IsGESign K A c q k i + · have hmem : (1 : A) ∈ Ideal.span (Set.range q) := by + rw [hq] + exact Submodule.mem_top + obtain ⟨a, ha⟩ := + Ideal.mem_span_range_iff_exists_fun.mp hmem + apply (Ideal.eq_top_iff_one _).mpr + rw [Ideal.mem_span_range_iff_exists_fun] + refine ⟨fun i ↦ chartBaseMap K A c q k + (algebraMap K A c⁻¹ * a i), ?_⟩ + simp only [localUnitFamily] + simp_rw [if_pos (hall _)] + simp_rw [← map_mul] + rw [← map_sum] + have hsum : + ∑ i, (algebraMap K A c⁻¹ * a i) * scaledFamily K A c q i = 1 := by + calc + ∑ i, (algebraMap K A c⁻¹ * a i) * scaledFamily K A c q i = + ∑ i, a i * q i := by + apply Finset.sum_congr rfl + intro i _ + rw [scaledFamily] + calc + (algebraMap K A c⁻¹ * a i) * (algebraMap K A c * q i) = + (algebraMap K A c⁻¹ * algebraMap K A c) * (a i * q i) := by + ring + _ = a i * q i := by + rw [← map_mul, inv_mul_cancel₀ hc, map_one, one_mul] + _ = 1 := ha + rw [hsum, map_one] + · obtain ⟨i, hi⟩ := not_forall.mp hall + apply (Ideal.eq_top_iff_one _).mpr + apply Ideal.subset_span + refine ⟨i, ?_⟩ + simp [localUnitFamily, hi] + +private noncomputable abbrev rebasedRestrictedGeneratedCover {r : ℕ} + (c : K) (q : Fin r → A) (hq : Ideal.span (Set.range q) = ⊤) + (k : Fin (scaledLaurentCover K A c q).m) : + Cover K ((scaledLaurentCover K A c q).domain k).Sections + (whole K ((scaledLaurentCover K A c q).domain k).Sections) := + ((generated K A q hq).restrictTo K A + ((scaledLaurentCover K A c q).domain k) (by + simpa only [carrier_whole] using + Set.subset_univ ((scaledLaurentCover K A c q).domain k).carrier)).rebase K A + +private noncomputable abbrev localGeneratedCover {r : ℕ} {c : K} (hc : c ≠ 0) + (q : Fin r → A) (hq : Ideal.span (Set.range q) = ⊤) + (k : Fin (scaledLaurentCover K A c q).m) : + Cover K ((scaledLaurentCover K A c q).domain k).Sections + (whole K ((scaledLaurentCover K A c q).domain k).Sections) := + generated K ((scaledLaurentCover K A c q).domain k).Sections + (localUnitFamily K A c q k) + (localUnitFamily_span_top K A hc q hq k) + +private theorem mem_rebasedRestrictedGeneratedCover_domain_iff {r : ℕ} + (c : K) (q : Fin r → A) (hq : Ideal.span (Set.range q) = ⊤) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) + (y : BerkovichSpectrumOver K + ((scaledLaurentCover K A c q).domain k).Sections) : + y ∈ ((rebasedRestrictedGeneratedCover K A c q hq k).domain i).carrier ↔ + ∀ j, ambientPoint K A ((scaledLaurentCover K A c q).domain k) y (q j) ≤ + ambientPoint K A ((scaledLaurentCover K A c q).domain k) y (q i) := by + rw [mem_rebase_carrier_iff, carrier_inter, Set.mem_inter_iff] + change + ambientPoint K A ((scaledLaurentCover K A c q).domain k) y ∈ + ((scaledLaurentCover K A c q).domain k).carrier ∧ + ambientPoint K A ((scaledLaurentCover K A c q).domain k) y ∈ + (generatedDomain K A q hq i).carrier ↔ _ + rw [mem_generatedDomain_carrier] + constructor + · exact fun h ↦ h.2 + · exact fun h ↦ + ⟨ambientPoint_mem_carrier K A + ((scaledLaurentCover K A c q).domain k) y, h⟩ + +private theorem chartBaseMap_scaled_le_iff {r : ℕ} {c : K} + (hc : 0 < ‖c‖) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i j : Fin r) + (y : BerkovichSpectrumOver K + ((scaledLaurentCover K A c q).domain k).Sections) : + y (chartBaseMap K A c q k (scaledFamily K A c q i)) ≤ + y (chartBaseMap K A c q k (scaledFamily K A c q j)) ↔ + ambientPoint K A ((scaledLaurentCover K A c q).domain k) y (q i) ≤ + ambientPoint K A ((scaledLaurentCover K A c q).domain k) y (q j) := by + rw [← ambientPoint_apply K A ((scaledLaurentCover K A c q).domain k), + ← ambientPoint_apply K A ((scaledLaurentCover K A c q).domain k)] + exact scaledFamily_le_scaledFamily_iff K A hc q i j _ + +private theorem ge_sign_value {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) + (hi : IsGESign K A c q k i) + (y : BerkovichSpectrumOver K + ((scaledLaurentCover K A c q).domain k).Sections) : + 1 ≤ y (chartBaseMap K A c q k (scaledFamily K A c q i)) := by + rw [← ambientPoint_apply K A ((scaledLaurentCover K A c q).domain k)] + exact hi _ (ambientPoint_mem_carrier K A + ((scaledLaurentCover K A c q).domain k) y) + +private theorem le_sign_value {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) + (hi : IsLESign K A c q k i) + (y : BerkovichSpectrumOver K + ((scaledLaurentCover K A c q).domain k).Sections) : + y (chartBaseMap K A c q k (scaledFamily K A c q i)) ≤ 1 := by + rw [← ambientPoint_apply K A ((scaledLaurentCover K A c q).domain k)] + exact hi _ (ambientPoint_mem_carrier K A + ((scaledLaurentCover K A c q).domain k) y) + +private noncomputable def geOwner {r : ℕ} (c : K) (q : Fin r → A) + (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) : Fin r := + Classical.choose (exists_ge_sign K A c q hr hlarge k) + +private theorem geOwner_spec {r : ℕ} (c : K) (q : Fin r → A) + (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) : + IsGESign K A c q k (geOwner K A c q hr hlarge k) := + Classical.choose_spec (exists_ge_sign K A c q hr hlarge k) + +private noncomputable def geIndex {r : ℕ} (c : K) (q : Fin r → A) + (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) : Fin r := by + classical + exact if IsGESign K A c q k i then i else geOwner K A c q hr hlarge k + +private noncomputable def rebasedRestrictedGeneratedRefinementLocal {r : ℕ} + {c : K} (hc : 0 < ‖c‖) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) : + Refinement K ((scaledLaurentCover K A c q).domain k).Sections + (rebasedRestrictedGeneratedCover K A c q hq k) + (localGeneratedCover K A (norm_pos_iff.mp hc) q hq k) where + index i := geIndex K A c q hr hlarge k i + subset i y hy := by + classical + change Fin r at i + have horig := + (mem_rebasedRestrictedGeneratedCover_domain_iff K A c q hq k i y).1 hy + change y ∈ (generatedDomain K + ((scaledLaurentCover K A c q).domain k).Sections + (localUnitFamily K A c q k) + (localUnitFamily_span_top K A (norm_pos_iff.mp hc) q hq k) + (geIndex K A c q hr hlarge k i)).carrier + rw [mem_generatedDomain_carrier] + intro j + by_cases hi : IsGESign K A c q k i + · simp only [geIndex, hi, if_pos] + by_cases hj : IsGESign K A c q k j + · rw [localUnitFamily, if_pos hj, localUnitFamily, if_pos hi] + exact + (chartBaseMap_scaled_le_iff K A hc q k j i y).2 (horig j) + · rw [localUnitFamily, if_neg hj, localUnitFamily, if_pos hi, + BerkovichSpectrumOver.map_one] + exact ge_sign_value K A c q k i hi y + · let owner := geOwner K A c q hr hlarge k + have hindex : + geIndex K A c q hr hlarge k i = owner := by + simp [geIndex, hi, owner] + rw [hindex] + have howner : IsGESign K A c q k owner := + geOwner_spec K A c q hr hlarge k + by_cases hj : IsGESign K A c q k j + · rw [localUnitFamily, if_pos hj, localUnitFamily, if_pos howner] + exact ((chartBaseMap_scaled_le_iff K A hc q k j i y).2 + (horig j)).trans + ((le_sign_value K A c q k i + (le_sign_of_not_ge K A c q k i hi) y).trans + (ge_sign_value K A c q k owner howner y)) + · rw [localUnitFamily, if_neg hj, localUnitFamily, if_pos howner, + BerkovichSpectrumOver.map_one] + exact ge_sign_value K A c q k owner howner y + +private noncomputable def localRefinementRebasedRestrictedGenerated {r : ℕ} + {c : K} (hc : 0 < ‖c‖) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) : + Refinement K ((scaledLaurentCover K A c q).domain k).Sections + (localGeneratedCover K A (norm_pos_iff.mp hc) q hq k) + (rebasedRestrictedGeneratedCover K A c q hq k) where + index i := geIndex K A c q hr hlarge k i + subset i y hy := by + classical + change Fin r at i + have hlocal : + ∀ j, y (localUnitFamily K A c q k j) ≤ + y (localUnitFamily K A c q k i) := by + change y ∈ (generatedDomain K + ((scaledLaurentCover K A c q).domain k).Sections + (localUnitFamily K A c q k) + (localUnitFamily_span_top K A (norm_pos_iff.mp hc) q hq k) i).carrier at hy + exact (mem_generatedDomain_carrier K + ((scaledLaurentCover K A c q).domain k).Sections + (localUnitFamily K A c q k) + (localUnitFamily_span_top K A (norm_pos_iff.mp hc) q hq k) i y).1 hy + apply + (mem_rebasedRestrictedGeneratedCover_domain_iff K A c q hq k + (geIndex K A c q hr hlarge k i) y).2 + intro j + by_cases hi : IsGESign K A c q k i + · simp only [geIndex, hi, if_pos] + apply (chartBaseMap_scaled_le_iff K A hc q k j i y).1 + by_cases hj : IsGESign K A c q k j + · simpa only [localUnitFamily, if_pos hj, if_pos hi] using hlocal j + · exact (le_sign_value K A c q k j + (le_sign_of_not_ge K A c q k j hj) y).trans + (ge_sign_value K A c q k i hi y) + · let owner := geOwner K A c q hr hlarge k + have hindex : + geIndex K A c q hr hlarge k i = owner := by + simp [geIndex, hi, owner] + rw [hindex] + have howner : IsGESign K A c q k owner := + geOwner_spec K A c q hr hlarge k + apply (chartBaseMap_scaled_le_iff K A hc q k j owner y).1 + by_cases hj : IsGESign K A c q k j + · have hjone : + y (chartBaseMap K A c q k (scaledFamily K A c q j)) ≤ 1 := by + simpa only [localUnitFamily, if_pos hj, if_neg hi, + BerkovichSpectrumOver.map_one] using hlocal j + exact hjone.trans (ge_sign_value K A c q k owner howner y) + · exact (le_sign_value K A c q k j + (le_sign_of_not_ge K A c q k j hj) y).trans + (ge_sign_value K A c q k owner howner y) + +/-- On a scaled Laurent chart, the restriction of a generated rational cover +is equivalent to a cover generated by units. -/ +private theorem restrictTo_generated_chart_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) {r : ℕ} {c : K} (hc : 0 < ‖c‖) + (q : Fin r → A) (hq : Ideal.span (Set.range q) = ⊤) + (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) : + (((generated K A q hq).restrictTo K A + ((scaledLaurentCover K A c q).domain k) + ((scaledLaurentCover K A c q).subset k)).normalizedCechComplex K A hA).Acyclic := by + rw [normalizedCechComplex_acyclic_iff_rebase K A hA] + exact + (normalizedCechComplex_acyclic_iff_of_mutual_refinement K + ((scaledLaurentCover K A c q).domain k).Sections + (isAffinoidAlgebra_sections K A hA + ((scaledLaurentCover K A c q).domain k)) + (rebasedRestrictedGeneratedCover K A c q hq k) + (localGeneratedCover K A (norm_pos_iff.mp hc) q hq k) + (localRefinementRebasedRestrictedGenerated K A hc q hq hr hlarge k) + (rebasedRestrictedGeneratedRefinementLocal K A hc q hq hr hlarge k)).2 + (unitGenerated_normalizedCechComplex_acyclic K + ((scaledLaurentCover K A c q).domain k).Sections + (isAffinoidAlgebra_sections K A hA + ((scaledLaurentCover K A c q).domain k)) + (localUnitFamily K A c q k) + (localUnitFamily_span_top K A (norm_pos_iff.mp hc) q hq k) + hr (localUnitFamily_isUnit K A c q k)) + +private noncomputable abbrev subdomainBaseMap + (W : AffinoidRationalSubdomain K A) : + ContinuousAlgHom K A W.Sections := + RationalLocalization.baseMap K A W.n W.g W.f + +/-- The unit family belonging to a scaled Laurent chart, pulled all the way +back to a rational subdomain of that chart. -/ +private noncomputable def localUnitFamilyOn {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) + (W : AffinoidRationalSubdomain K A) : Fin r → W.Sections := by + classical + exact fun i ↦ if IsGESign K A c q k i then + subdomainBaseMap K A W (scaledFamily K A c q i) + else 1 + +private theorem localUnitFamilyOn_isUnit {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) + (W : AffinoidRationalSubdomain K A) + (hW : W.carrier ⊆ ((scaledLaurentCover K A c q).domain k).carrier) + (i : Fin r) : + IsUnit (localUnitFamilyOn K A c q k W i) := by + by_cases hi : IsGESign K A c q k i + · rw [localUnitFamilyOn, if_pos hi] + rw [BerkovichSpectrumOver.isUnit_iff_forall_apply_ne_zero K W.Sections] + intro y + have hval := hi (ambientPoint K A W y) + (hW (ambientPoint_mem_carrier K A W y)) + rw [ambientPoint_apply K A W] at hval + exact ne_of_gt (zero_lt_one.trans_le hval) + · rw [localUnitFamilyOn, if_neg hi] + exact isUnit_one + +private theorem localUnitFamilyOn_span_top {r : ℕ} {c : K} (hc : c ≠ 0) + (q : Fin r → A) (hq : Ideal.span (Set.range q) = ⊤) + (k : Fin (scaledLaurentCover K A c q).m) + (W : AffinoidRationalSubdomain K A) : + Ideal.span (Set.range (localUnitFamilyOn K A c q k W)) = ⊤ := by + classical + by_cases hall : ∀ i, IsGESign K A c q k i + · have hmem : (1 : A) ∈ Ideal.span (Set.range q) := by + rw [hq] + exact Submodule.mem_top + obtain ⟨a, ha⟩ := + Ideal.mem_span_range_iff_exists_fun.mp hmem + apply (Ideal.eq_top_iff_one _).mpr + rw [Ideal.mem_span_range_iff_exists_fun] + refine ⟨fun i ↦ subdomainBaseMap K A W + (algebraMap K A c⁻¹ * a i), ?_⟩ + simp only [localUnitFamilyOn] + simp_rw [if_pos (hall _)] + simp_rw [← map_mul] + rw [← map_sum] + have hsum : + ∑ i, (algebraMap K A c⁻¹ * a i) * scaledFamily K A c q i = 1 := by + calc + ∑ i, (algebraMap K A c⁻¹ * a i) * scaledFamily K A c q i = + ∑ i, a i * q i := by + apply Finset.sum_congr rfl + intro i _ + rw [scaledFamily] + calc + (algebraMap K A c⁻¹ * a i) * (algebraMap K A c * q i) = + (algebraMap K A c⁻¹ * algebraMap K A c) * (a i * q i) := by + ring + _ = a i * q i := by + rw [← map_mul, inv_mul_cancel₀ hc, map_one, one_mul] + _ = 1 := ha + rw [hsum, map_one] + · obtain ⟨i, hi⟩ := not_forall.mp hall + apply (Ideal.eq_top_iff_one _).mpr + apply Ideal.subset_span + refine ⟨i, ?_⟩ + simp [localUnitFamilyOn, hi] + +private noncomputable abbrev rebasedRestrictedGeneratedCoverOn {r : ℕ} + (q : Fin r → A) (hq : Ideal.span (Set.range q) = ⊤) + (W : AffinoidRationalSubdomain K A) : + Cover K W.Sections (whole K W.Sections) := + ((generated K A q hq).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier)).rebase K A + +private noncomputable abbrev localGeneratedCoverOn {r : ℕ} {c : K} + (hc : c ≠ 0) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) + (k : Fin (scaledLaurentCover K A c q).m) + (W : AffinoidRationalSubdomain K A) : + Cover K W.Sections (whole K W.Sections) := + generated K W.Sections (localUnitFamilyOn K A c q k W) + (localUnitFamilyOn_span_top K A hc q hq k W) + +private theorem mem_rebasedRestrictedGeneratedCoverOn_domain_iff {r : ℕ} + (q : Fin r → A) (hq : Ideal.span (Set.range q) = ⊤) + (W : AffinoidRationalSubdomain K A) (i : Fin r) + (y : BerkovichSpectrumOver K W.Sections) : + y ∈ ((rebasedRestrictedGeneratedCoverOn K A q hq W).domain i).carrier ↔ + ∀ j, ambientPoint K A W y (q j) ≤ ambientPoint K A W y (q i) := by + rw [mem_rebase_carrier_iff, carrier_inter, Set.mem_inter_iff] + change + ambientPoint K A W y ∈ W.carrier ∧ + ambientPoint K A W y ∈ (generatedDomain K A q hq i).carrier ↔ _ + rw [mem_generatedDomain_carrier] + constructor + · exact fun h ↦ h.2 + · exact fun h ↦ ⟨ambientPoint_mem_carrier K A W y, h⟩ + +private theorem subdomainBaseMap_scaled_le_iff {r : ℕ} {c : K} + (hc : 0 < ‖c‖) (q : Fin r → A) + (W : AffinoidRationalSubdomain K A) (i j : Fin r) + (y : BerkovichSpectrumOver K W.Sections) : + y (subdomainBaseMap K A W (scaledFamily K A c q i)) ≤ + y (subdomainBaseMap K A W (scaledFamily K A c q j)) ↔ + ambientPoint K A W y (q i) ≤ ambientPoint K A W y (q j) := by + rw [← ambientPoint_apply K A W, ← ambientPoint_apply K A W] + exact scaledFamily_le_scaledFamily_iff K A hc q i j _ + +private theorem ge_sign_value_on {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) + (hi : IsGESign K A c q k i) + (W : AffinoidRationalSubdomain K A) + (hW : W.carrier ⊆ ((scaledLaurentCover K A c q).domain k).carrier) + (y : BerkovichSpectrumOver K W.Sections) : + 1 ≤ y (subdomainBaseMap K A W (scaledFamily K A c q i)) := by + rw [← ambientPoint_apply K A W] + exact hi _ (hW (ambientPoint_mem_carrier K A W y)) + +private theorem le_sign_value_on {r : ℕ} (c : K) (q : Fin r → A) + (k : Fin (scaledLaurentCover K A c q).m) (i : Fin r) + (hi : IsLESign K A c q k i) + (W : AffinoidRationalSubdomain K A) + (hW : W.carrier ⊆ ((scaledLaurentCover K A c q).domain k).carrier) + (y : BerkovichSpectrumOver K W.Sections) : + y (subdomainBaseMap K A W (scaledFamily K A c q i)) ≤ 1 := by + rw [← ambientPoint_apply K A W] + exact hi _ (hW (ambientPoint_mem_carrier K A W y)) + +private noncomputable def rebasedRestrictedGeneratedOnRefinementLocal {r : ℕ} + {c : K} (hc : 0 < ‖c‖) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) + (W : AffinoidRationalSubdomain K A) + (hW : W.carrier ⊆ ((scaledLaurentCover K A c q).domain k).carrier) : + Refinement K W.Sections + (rebasedRestrictedGeneratedCoverOn K A q hq W) + (localGeneratedCoverOn K A (norm_pos_iff.mp hc) q hq k W) where + index i := geIndex K A c q hr hlarge k i + subset i y hy := by + classical + change Fin r at i + have horig := + (mem_rebasedRestrictedGeneratedCoverOn_domain_iff K A q hq W i y).1 hy + change y ∈ (generatedDomain K W.Sections + (localUnitFamilyOn K A c q k W) + (localUnitFamilyOn_span_top K A (norm_pos_iff.mp hc) q hq k W) + (geIndex K A c q hr hlarge k i)).carrier + rw [mem_generatedDomain_carrier] + intro j + by_cases hi : IsGESign K A c q k i + · simp only [geIndex, hi, if_pos] + by_cases hj : IsGESign K A c q k j + · rw [localUnitFamilyOn, if_pos hj, localUnitFamilyOn, if_pos hi] + exact (subdomainBaseMap_scaled_le_iff K A hc q W j i y).2 (horig j) + · rw [localUnitFamilyOn, if_neg hj, localUnitFamilyOn, if_pos hi, + BerkovichSpectrumOver.map_one] + exact ge_sign_value_on K A c q k i hi W hW y + · let owner := geOwner K A c q hr hlarge k + have hindex : geIndex K A c q hr hlarge k i = owner := by + simp [geIndex, hi, owner] + rw [hindex] + have howner : IsGESign K A c q k owner := + geOwner_spec K A c q hr hlarge k + by_cases hj : IsGESign K A c q k j + · rw [localUnitFamilyOn, if_pos hj, localUnitFamilyOn, if_pos howner] + exact ((subdomainBaseMap_scaled_le_iff K A hc q W j i y).2 + (horig j)).trans + ((le_sign_value_on K A c q k i + (le_sign_of_not_ge K A c q k i hi) W hW y).trans + (ge_sign_value_on K A c q k owner howner W hW y)) + · rw [localUnitFamilyOn, if_neg hj, localUnitFamilyOn, if_pos howner, + BerkovichSpectrumOver.map_one] + exact ge_sign_value_on K A c q k owner howner W hW y + +private noncomputable def localRefinementRebasedRestrictedGeneratedOn {r : ℕ} + {c : K} (hc : 0 < ‖c‖) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) + (W : AffinoidRationalSubdomain K A) + (hW : W.carrier ⊆ ((scaledLaurentCover K A c q).domain k).carrier) : + Refinement K W.Sections + (localGeneratedCoverOn K A (norm_pos_iff.mp hc) q hq k W) + (rebasedRestrictedGeneratedCoverOn K A q hq W) where + index i := geIndex K A c q hr hlarge k i + subset i y hy := by + classical + change Fin r at i + have hlocal : + ∀ j, y (localUnitFamilyOn K A c q k W j) ≤ + y (localUnitFamilyOn K A c q k W i) := by + change y ∈ (generatedDomain K W.Sections + (localUnitFamilyOn K A c q k W) + (localUnitFamilyOn_span_top K A (norm_pos_iff.mp hc) q hq k W) + i).carrier at hy + exact (mem_generatedDomain_carrier K W.Sections + (localUnitFamilyOn K A c q k W) + (localUnitFamilyOn_span_top K A (norm_pos_iff.mp hc) q hq k W) + i y).1 hy + apply + (mem_rebasedRestrictedGeneratedCoverOn_domain_iff K A q hq W + (geIndex K A c q hr hlarge k i) y).2 + intro j + by_cases hi : IsGESign K A c q k i + · simp only [geIndex, hi, if_pos] + apply (subdomainBaseMap_scaled_le_iff K A hc q W j i y).1 + by_cases hj : IsGESign K A c q k j + · simpa only [localUnitFamilyOn, if_pos hj, if_pos hi] using hlocal j + · exact (le_sign_value_on K A c q k j + (le_sign_of_not_ge K A c q k j hj) W hW y).trans + (ge_sign_value_on K A c q k i hi W hW y) + · let owner := geOwner K A c q hr hlarge k + have hindex : geIndex K A c q hr hlarge k i = owner := by + simp [geIndex, hi, owner] + rw [hindex] + have howner : IsGESign K A c q k owner := + geOwner_spec K A c q hr hlarge k + apply (subdomainBaseMap_scaled_le_iff K A hc q W j owner y).1 + by_cases hj : IsGESign K A c q k j + · have hjone : + y (subdomainBaseMap K A W (scaledFamily K A c q j)) ≤ 1 := by + simpa only [localUnitFamilyOn, if_pos hj, if_neg hi, + BerkovichSpectrumOver.map_one] using hlocal j + exact hjone.trans (ge_sign_value_on K A c q k owner howner W hW y) + · exact (le_sign_value_on K A c q k j + (le_sign_of_not_ge K A c q k j hj) W hW y).trans + (ge_sign_value_on K A c q k owner howner W hW y) + +/-- The generated cover remains acyclic after restriction to every rational +subdomain contained in one chart of the scaled Laurent cover. -/ +private theorem restrictTo_generated_inside_chart_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) {r : ℕ} {c : K} (hc : 0 < ‖c‖) + (q : Fin r → A) (hq : Ideal.span (Set.range q) = ⊤) + (hr : Nonempty (Fin r)) + (hlarge : ∀ x : BerkovichSpectrumOver K A, + ∃ i : Fin r, 1 < x (scaledFamily K A c q i)) + (k : Fin (scaledLaurentCover K A c q).m) + (W : AffinoidRationalSubdomain K A) + (hW : W.carrier ⊆ ((scaledLaurentCover K A c q).domain k).carrier) : + (((generated K A q hq).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier) + ).normalizedCechComplex K A hA).Acyclic := by + rw [normalizedCechComplex_acyclic_iff_rebase K A hA] + exact + (normalizedCechComplex_acyclic_iff_of_mutual_refinement K W.Sections + (isAffinoidAlgebra_sections K A hA W) + (rebasedRestrictedGeneratedCoverOn K A q hq W) + (localGeneratedCoverOn K A (norm_pos_iff.mp hc) q hq k W) + (localRefinementRebasedRestrictedGeneratedOn + K A hc q hq hr hlarge k W hW) + (rebasedRestrictedGeneratedOnRefinementLocal + K A hc q hq hr hlarge k W hW)).2 + (unitGenerated_normalizedCechComplex_acyclic K W.Sections + (isAffinoidAlgebra_sections K A hA W) + (localUnitFamilyOn K A c q k W) + (localUnitFamilyOn_span_top K A (norm_pos_iff.mp hc) q hq k W) + hr (localUnitFamilyOn_isUnit K A c q k W hW)) + +/-- A rational cover generated by a finite family spanning the unit ideal is +Čech-acyclic. The proof is the scaled-Laurent reduction of BGR 8.2.2, +Lemma 3, combined with the double-Čech comparison theorem. -/ +theorem generated_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) {r : ℕ} (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (hr : Nonempty (Fin r)) : + ((generated K A q hq).normalizedCechComplex K A hA).Acyclic := by + obtain ⟨c, hc, hlarge⟩ := exists_scalingConstant K A q hq hr + apply normalizedCechComplex_acyclic_of_double K A hA + (generated K A q hq) (scaledLaurentCover K A c q) + (laurentProduct_normalizedCechComplex_acyclic K A hA + 1 (scaledFamilyList K A c q)) + · intro p + have hvertical : + (Cech.Presheaf.Family.verticalAugmentedCofaceModule + ((scaledLaurentCover K A c q).cechFamily K A hA) + ((generated K A q hq).cechFamily K A hA) p).complex.Acyclic := by + apply verticalAugmentedCofaceModule_acyclic_of_restrictTo + K A hA (scaledLaurentCover K A c q) (generated K A q hq) p + intro σ + exact + restrictTo_generated_inside_chart_normalizedCechComplex_acyclic + K A hA hc q hq hr hlarge (σ 0) + (((scaledLaurentCover K A c q).cechFamily K A hA).tupleInter p σ) + (((scaledLaurentCover K A c q).cechFamily K A hA + ).tupleInter_subset_domain p σ 0) + intro n + exact (hvertical n).of_iso + (Cech.Presheaf.Family.verticalAugmentedCofaceModuleIso + ((scaledLaurentCover K A c q).cechFamily K A hA) + ((generated K A q hq).cechFamily K A hA) p) + · intro p + apply verticalAugmentedCofaceModule_acyclic_of_restrictTo + K A hA (generated K A q hq) (scaledLaurentCover K A c q) p + intro σ + exact restrictTo_laurentProduct_normalizedCechComplex_acyclic K A hA + (((generated K A q hq).cechFamily K A hA).tupleInter p σ) + 1 (scaledFamilyList K A c q) + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/GeneratedRestriction.lean b/Rigid/AffinoidSpectrum/GeneratedRestriction.lean new file mode 100644 index 0000000..f12b762 --- /dev/null +++ b/Rigid/AffinoidSpectrum/GeneratedRestriction.lean @@ -0,0 +1,119 @@ +import Rigid.AffinoidSpectrum.GeneratedCoverReduction + +set_option linter.style.header false + +/-! +# Generated rational covers restricted to rational subdomains + +After restriction to a rational subdomain and rebasing, a generated rational +cover is the cover generated by the images of the same finite family. This +gives the universal form of generated-cover acyclicity needed in Čech +comparison arguments. +-/ + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +private noncomputable abbrev mappedGeneratedFamily {r : ℕ} + (W : AffinoidRationalSubdomain K A) (q : Fin r → A) : Fin r → W.Sections := + fun i ↦ RationalLocalization.baseMap K A W.n W.g W.f (q i) + +private theorem mappedGeneratedFamily_span_top {r : ℕ} + (W : AffinoidRationalSubdomain K A) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) : + Ideal.span (Set.range (mappedGeneratedFamily K A W q)) = ⊤ := by + classical + have hmem : (1 : A) ∈ Ideal.span (Set.range q) := by + rw [hq] + exact Submodule.mem_top + obtain ⟨a, ha⟩ := Ideal.mem_span_range_iff_exists_fun.mp hmem + apply (Ideal.eq_top_iff_one _).mpr + rw [Ideal.mem_span_range_iff_exists_fun] + refine ⟨fun i ↦ RationalLocalization.baseMap K A W.n W.g W.f (a i), ?_⟩ + simp only [mappedGeneratedFamily] + simp_rw [← map_mul] + rw [← map_sum, ha, map_one] + +private noncomputable abbrev rebasedRestrictedGenerated {r : ℕ} + (W : AffinoidRationalSubdomain K A) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) : + Cover K W.Sections (whole K W.Sections) := + ((generated K A q hq).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier)).rebase K A + +private noncomputable abbrev mappedGenerated {r : ℕ} + (W : AffinoidRationalSubdomain K A) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) : + Cover K W.Sections (whole K W.Sections) := + generated K W.Sections (mappedGeneratedFamily K A W q) + (mappedGeneratedFamily_span_top K A W q hq) + +private theorem rebase_restrictTo_generated_domain_carrier_eq {r : ℕ} + (W : AffinoidRationalSubdomain K A) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (i : Fin r) : + ((rebasedRestrictedGenerated K A W q hq).domain i).carrier = + ((mappedGenerated K A W q hq).domain i).carrier := by + ext y + rw [mem_rebase_carrier_iff] + change + ambientPoint K A W y ∈ (inter K A W (generatedDomain K A q hq i)).carrier ↔ + y ∈ (generatedDomain K W.Sections + (mappedGeneratedFamily K A W q) + (mappedGeneratedFamily_span_top K A W q hq) i).carrier + rw [carrier_inter, Set.mem_inter_iff, mem_generatedDomain_carrier, + mem_generatedDomain_carrier] + simp_rw [← ambientPoint_apply K A W] + constructor + · exact And.right + · exact fun h ↦ ⟨ambientPoint_mem_carrier K A W y, h⟩ + +private noncomputable def mappedGeneratedRefinementRebasedRestricted {r : ℕ} + (W : AffinoidRationalSubdomain K A) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) : + Refinement K W.Sections + (mappedGenerated K A W q hq) + (rebasedRestrictedGenerated K A W q hq) where + index i := i + subset i := (rebase_restrictTo_generated_domain_carrier_eq K A W q hq i).ge + +private noncomputable def rebasedRestrictedRefinementMappedGenerated {r : ℕ} + (W : AffinoidRationalSubdomain K A) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) : + Refinement K W.Sections + (rebasedRestrictedGenerated K A W q hq) + (mappedGenerated K A W q hq) where + index i := i + subset i := (rebase_restrictTo_generated_domain_carrier_eq K A W q hq i).le + +/-- A cover generated by a finite unit-ideal family remains acyclic after +restriction to every rational subdomain. -/ +theorem restrictTo_generated_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) {r : ℕ} + (W : AffinoidRationalSubdomain K A) (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (hr : Nonempty (Fin r)) : + (((generated K A q hq).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier) + ).normalizedCechComplex K A hA).Acyclic := by + rw [normalizedCechComplex_acyclic_iff_rebase K A hA] + exact + (normalizedCechComplex_acyclic_iff_of_mutual_refinement K W.Sections + (isAffinoidAlgebra_sections K A hA W) + (rebasedRestrictedGenerated K A W q hq) + (mappedGenerated K A W q hq) + (mappedGeneratedRefinementRebasedRestricted K A W q hq) + (rebasedRestrictedRefinementMappedGenerated K A W q hq)).2 + (generated_normalizedCechComplex_acyclic K W.Sections + (isAffinoidAlgebra_sections K A hA W) + (mappedGeneratedFamily K A W q) + (mappedGeneratedFamily_span_top K A W q hq) hr) + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/LaurentCech.lean b/Rigid/AffinoidSpectrum/LaurentCech.lean new file mode 100644 index 0000000..1c78a6d --- /dev/null +++ b/Rigid/AffinoidSpectrum/LaurentCech.lean @@ -0,0 +1,660 @@ +import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex +import Rigid.AffinoidAlgebra.LaurentIntersectionMaps +import Rigid.AffinoidSpectrum.Cech + +set_option linter.style.header false + +/-! +# The normalized Čech complex of a Laurent cover + +This file identifies the first three terms of the normalized Čech complex of the two-member +Laurent cover with the short exact sequence constructed in `LaurentIntersectionMaps`. +-/ + +open CategoryTheory + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain + +/-- A rational datum for the Laurent overlap `|f| = 1` whose section algebra is the direct +Laurent intersection used by the established short exact sequence. -/ +noncomputable def laurentIntersectionDomain (f : A) : + AffinoidRationalSubdomain K A where + n := 2 + g := f + f := CompletedLaurent.laurentIntersectionNumerator A f + isRational := by + rw [IsRationalDatum] + apply (Ideal.eq_top_iff_one _).mpr + apply Ideal.subset_span + apply Set.mem_insert_of_mem + refine ⟨1, ?_⟩ + simp [CompletedLaurent.laurentIntersectionNumerator] + +@[simp] +theorem mem_laurentIntersectionDomain_carrier (f : A) (x : BerkovichSpectrumOver K A) : + x ∈ (laurentIntersectionDomain K A f).carrier ↔ x f = 1 := by + change + (∀ i : Fin 2, + x (CompletedLaurent.laurentIntersectionNumerator A f i) ≤ x f) ↔ + x f = 1 + constructor + · intro hx + have h0 := hx 0 + have h1 := hx 1 + have hnonneg := BerkovichSpectrumOver.nonneg K A x f + simp only [CompletedLaurent.laurentIntersectionNumerator, Matrix.cons_val_zero, + Matrix.cons_val_one, map_pow, BerkovichSpectrumOver.map_one] at h0 h1 + nlinarith + · intro hx + intro i + fin_cases i <;> + simp [CompletedLaurent.laurentIntersectionNumerator, hx] + +/-- The product rational datum for the intersection of the two Laurent charts and the direct +Laurent-intersection datum cut out the same point set. -/ +theorem carrier_inter_laurent_eq_laurentIntersectionDomain (f : A) : + (inter K A (laurentLE K A f) (laurentGE K A f)).carrier = + (laurentIntersectionDomain K A f).carrier := by + ext x + rw [carrier_inter] + simp only [Set.mem_inter_iff, mem_carrier_laurentLE, mem_carrier_laurentGE, + mem_laurentIntersectionDomain_carrier] + exact (le_antisymm_iff).symm + +namespace Cover + +private noncomputable def standardOverlapToDirect (hA : IsAffinoidAlgebra K A) (f : A) : + ContinuousAlgHom K + (inter K A (laurentLE K A f) (laurentGE K A f)).Sections + (laurentIntersectionDomain K A f).Sections := + restriction K A hA + (carrier_inter_laurent_eq_laurentIntersectionDomain K A f).ge + +private theorem plusRestriction_comp_plusMap + (hA : IsAffinoidAlgebra K A) (f : A) : + (restriction K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f))).comp + (LaurentCharts.plusMap K A f) = + RationalLocalization.baseMap K A + (inter K A (laurentLE K A f) (laurentGE K A f)).n + (inter K A (laurentLE K A f) (laurentGE K A f)).g + (inter K A (laurentLE K A f) (laurentGE K A f)).f := by + simpa only [LaurentCharts.plusMap, laurentLE] using + restriction_comp_baseMap K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f)) + +private theorem minusRestriction_comp_minusMap + (hA : IsAffinoidAlgebra K A) (f : A) : + (restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f))).comp + (LaurentCharts.minusMap K A f) = + RationalLocalization.baseMap K A + (inter K A (laurentLE K A f) (laurentGE K A f)).n + (inter K A (laurentLE K A f) (laurentGE K A f)).g + (inter K A (laurentLE K A f) (laurentGE K A f)).f := by + simpa only [LaurentCharts.minusMap, laurentGE] using + restriction_comp_baseMap K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f)) + +private theorem standardOverlapToDirect_comp_baseMap + (hA : IsAffinoidAlgebra K A) (f : A) : + (standardOverlapToDirect K A hA f).comp + (RationalLocalization.baseMap K A + (inter K A (laurentLE K A f) (laurentGE K A f)).n + (inter K A (laurentLE K A f) (laurentGE K A f)).g + (inter K A (laurentLE K A f) (laurentGE K A f)).f) = + RationalLocalization.baseMap K A 2 f + (CompletedLaurent.laurentIntersectionNumerator A f) := by + simpa only [standardOverlapToDirect, laurentIntersectionDomain] using + restriction_comp_baseMap K A hA + (carrier_inter_laurent_eq_laurentIntersectionDomain K A f).ge + +private theorem standardOverlapToDirect_comp_plusRestriction + (hA : IsAffinoidAlgebra K A) (f : A) : + (standardOverlapToDirect K A hA f).comp + (restriction K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f))) = + CompletedLaurent.plusToLaurentIntersection K A f := by + change + ((standardOverlapToDirect K A hA f).comp + (restriction K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f))) : + ContinuousAlgHom K (LaurentCharts.Plus K A f) + (CompletedLaurent.LaurentIntersection K A f)) = + CompletedLaurent.plusToLaurentIntersection K A f + apply RationalLocalization.hom_ext_of_isUnit K A + · have hunit : IsUnit (1 : (laurentIntersectionDomain K A f).Sections) := + isUnit_one + simpa only [map_one] using hunit + · calc + ((standardOverlapToDirect K A hA f).comp + (restriction K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f)))).comp + (LaurentCharts.plusMap K A f) = + (standardOverlapToDirect K A hA f).comp + ((restriction K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f))).comp + (LaurentCharts.plusMap K A f)) := + ContinuousAlgHom.comp_assoc _ _ _ + _ = (standardOverlapToDirect K A hA f).comp + (RationalLocalization.baseMap K A + (inter K A (laurentLE K A f) (laurentGE K A f)).n + (inter K A (laurentLE K A f) (laurentGE K A f)).g + (inter K A (laurentLE K A f) (laurentGE K A f)).f) := by + rw [plusRestriction_comp_plusMap K A hA f] + _ = RationalLocalization.baseMap K A 2 f + (CompletedLaurent.laurentIntersectionNumerator A f) := + standardOverlapToDirect_comp_baseMap K A hA f + _ = (CompletedLaurent.plusToLaurentIntersection K A f).comp + (LaurentCharts.plusMap K A f) := + (CompletedLaurent.plusToLaurentIntersection_comp_plusMap K A f).symm + +private theorem standardOverlapToDirect_comp_minusRestriction + (hA : IsAffinoidAlgebra K A) (f : A) : + (standardOverlapToDirect K A hA f).comp + (restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f))) = + CompletedLaurent.minusToLaurentIntersection K A f := by + change + ((standardOverlapToDirect K A hA f).comp + (restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f))) : + ContinuousAlgHom K (LaurentCharts.Minus K A f) + (CompletedLaurent.LaurentIntersection K A f)) = + CompletedLaurent.minusToLaurentIntersection K A f + apply RationalLocalization.hom_ext_of_isUnit K A + · have hbase : + ((standardOverlapToDirect K A hA f).comp + (restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f)))).comp + (LaurentCharts.minusMap K A f) = + RationalLocalization.baseMap K A 2 f + (CompletedLaurent.laurentIntersectionNumerator A f) := by + calc + _ = (standardOverlapToDirect K A hA f).comp + ((restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f))).comp + (LaurentCharts.minusMap K A f)) := + ContinuousAlgHom.comp_assoc _ _ _ + _ = (standardOverlapToDirect K A hA f).comp + (RationalLocalization.baseMap K A + (inter K A (laurentLE K A f) (laurentGE K A f)).n + (inter K A (laurentLE K A f) (laurentGE K A f)).g + (inter K A (laurentLE K A f) (laurentGE K A f)).f) := by + rw [minusRestriction_comp_minusMap K A hA f] + _ = _ := standardOverlapToDirect_comp_baseMap K A hA f + change IsUnit + (((standardOverlapToDirect K A hA f).comp + (restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f)))).comp + (LaurentCharts.minusMap K A f) f) + rw [hbase] + exact RationalLocalization.isUnit_baseMap_denominator K A 2 f + (CompletedLaurent.laurentIntersectionNumerator A f) + (laurentIntersectionDomain K A f).isRational + · calc + ((standardOverlapToDirect K A hA f).comp + (restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f)))).comp + (LaurentCharts.minusMap K A f) = + (standardOverlapToDirect K A hA f).comp + ((restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f))).comp + (LaurentCharts.minusMap K A f)) := + ContinuousAlgHom.comp_assoc _ _ _ + _ = (standardOverlapToDirect K A hA f).comp + (RationalLocalization.baseMap K A + (inter K A (laurentLE K A f) (laurentGE K A f)).n + (inter K A (laurentLE K A f) (laurentGE K A f)).g + (inter K A (laurentLE K A f) (laurentGE K A f)).f) := by + rw [minusRestriction_comp_minusMap K A hA f] + _ = RationalLocalization.baseMap K A 2 f + (CompletedLaurent.laurentIntersectionNumerator A f) := + standardOverlapToDirect_comp_baseMap K A hA f + _ = (CompletedLaurent.minusToLaurentIntersection K A f).comp + (LaurentCharts.minusMap K A f) := + (CompletedLaurent.minusToLaurentIntersection_comp_minusMap K A f).symm + +/-! ## The three terms of the normalized complex -/ + +private noncomputable def laurentLeftIndex (f : A) : Fin (laurent K A f).m := by + change Fin 2 + exact 0 + +private noncomputable def laurentRightIndex (f : A) : Fin (laurent K A f).m := by + change Fin 2 + exact 1 + +@[simp] +private theorem laurent_domain_leftIndex (f : A) : + (laurent K A f).domain (laurentLeftIndex K A f) = laurentLE K A f := by + change (![laurentLE K A f, laurentGE K A f] : Fin 2 → + AffinoidRationalSubdomain K A) 0 = laurentLE K A f + rfl + +@[simp] +private theorem laurent_domain_rightIndex (f : A) : + (laurent K A f).domain (laurentRightIndex K A f) = laurentGE K A f := by + change (![laurentLE K A f, laurentGE K A f] : Fin 2 → + AffinoidRationalSubdomain K A) 1 = laurentGE K A f + rfl + +/-- The unique increasing pair of indices in the two-member Laurent cover. -/ +private noncomputable def laurentPairTuple (hA : IsAffinoidAlgebra K A) (f : A) : + ((laurent K A f).cechFamily K A hA).StrictTuple 1 := by + change Fin 2 ↪o Fin 2 + exact OrderEmbedding.id _ + +private noncomputable def laurentLeftTuple (hA : IsAffinoidAlgebra K A) (f : A) : + ((laurent K A f).cechFamily K A hA).StrictTuple 0 := + ((laurent K A f).cechFamily K A hA).strictDelete 1 + (laurentPairTuple K A hA f) + +private noncomputable def laurentRightTuple (hA : IsAffinoidAlgebra K A) (f : A) : + ((laurent K A f).cechFamily K A hA).StrictTuple 0 := + ((laurent K A f).cechFamily K A hA).strictDelete 0 + (laurentPairTuple K A hA f) + +@[simp] +private theorem laurentLeftTuple_apply (hA : IsAffinoidAlgebra K A) (f : A) : + laurentLeftTuple K A hA f 0 = laurentLeftIndex K A f := + rfl + +@[simp] +private theorem laurentRightTuple_apply (hA : IsAffinoidAlgebra K A) (f : A) : + laurentRightTuple K A hA f 0 = laurentRightIndex K A f := + rfl + +private theorem wholeToLeftRestriction_comp_baseMap + (hA : IsAffinoidAlgebra K A) (f : A) : + (restriction K A hA + ((laurent K A f).subset (laurentLeftTuple K A hA f 0))).comp + (RationalLocalization.baseMap K A (whole K A).n (whole K A).g + (whole K A).f) = + LaurentCharts.plusMap K A f := by + calc + _ = RationalLocalization.baseMap K A + ((laurent K A f).domain (laurentLeftTuple K A hA f 0)).n + ((laurent K A f).domain (laurentLeftTuple K A hA f 0)).g + ((laurent K A f).domain (laurentLeftTuple K A hA f 0)).f := + restriction_comp_baseMap K A hA + ((laurent K A f).subset (laurentLeftTuple K A hA f 0)) + _ = LaurentCharts.plusMap K A f := by rfl + +private theorem wholeToRightRestriction_comp_baseMap + (hA : IsAffinoidAlgebra K A) (f : A) : + (restriction K A hA + ((laurent K A f).subset (laurentRightTuple K A hA f 0))).comp + (RationalLocalization.baseMap K A (whole K A).n (whole K A).g + (whole K A).f) = + LaurentCharts.minusMap K A f := by + calc + _ = RationalLocalization.baseMap K A + ((laurent K A f).domain (laurentRightTuple K A hA f 0)).n + ((laurent K A f).domain (laurentRightTuple K A hA f 0)).g + ((laurent K A f).domain (laurentRightTuple K A hA f 0)).f := + restriction_comp_baseMap K A hA + ((laurent K A f).subset (laurentRightTuple K A hA f 0)) + _ = LaurentCharts.minusMap K A f := by rfl + +private theorem laurentStrictTuple_zero_eq_left_or_right + (hA : IsAffinoidAlgebra K A) (f : A) + (σ : ((laurent K A f).cechFamily K A hA).StrictTuple 0) : + σ = laurentLeftTuple K A hA f ∨ σ = laurentRightTuple K A hA f := by + change Fin 1 ↪o Fin 2 at σ + have hval : (σ 0).val = 0 ∨ (σ 0).val = 1 := by omega + rcases hval with hval | hval + · have h : σ 0 = 0 := Fin.ext hval + left + ext i + have hi : i = 0 := Fin.eq_zero i + subst i + exact congrArg Fin.val h + · have h : σ 0 = 1 := Fin.ext hval + right + ext i + have hi : i = 0 := Fin.eq_zero i + subst i + exact congrArg Fin.val h + +private noncomputable def laurentChartCochainsEquiv + (hA : IsAffinoidAlgebra K A) (f : A) : + ((laurent K A f).cechFamily K A hA).NormalizedCochains 0 ≃ₗ[K] + LaurentCharts.Plus K A f × LaurentCharts.Minus K A f where + toFun s := + (s (laurentLeftTuple K A hA f), s (laurentRightTuple K A hA f)) + invFun pq := by + intro σ + by_cases hσ : σ = laurentLeftTuple K A hA f + · subst σ + exact pq.1 + · have hσ' := + (laurentStrictTuple_zero_eq_left_or_right K A hA f σ).resolve_left hσ + subst σ + exact pq.2 + left_inv s := by + funext σ + rcases laurentStrictTuple_zero_eq_left_or_right K A hA f σ with hσ | hσ + · subst σ + rfl + · subst σ + rfl + right_inv pq := rfl + map_add' _ _ := rfl + map_smul' _ _ := rfl + +private theorem laurentStrictTuple_one_eq_pair + (hA : IsAffinoidAlgebra K A) (f : A) + (σ : ((laurent K A f).cechFamily K A hA).StrictTuple 1) : + σ = laurentPairTuple K A hA f := by + change (σ : Fin 2 ↪o Fin 2) = OrderEmbedding.id _ + change Fin 2 ↪o Fin 2 at σ + have hlt : σ 0 < σ 1 := σ.strictMono (by decide) + have h0 : (σ 0).val = 0 := by omega + have h1 : (σ 1).val = 1 := by omega + ext i + fin_cases i + · simpa using h0 + · simpa using h1 + +private theorem laurentPair_delete_zero + (hA : IsAffinoidAlgebra K A) (f : A) : + ((laurent K A f).cechFamily K A hA).strictDelete 0 + (laurentPairTuple K A hA f) = + laurentRightTuple K A hA f := by + rfl + +private theorem laurentPair_delete_one + (hA : IsAffinoidAlgebra K A) (f : A) : + ((laurent K A f).cechFamily K A hA).strictDelete 1 + (laurentPairTuple K A hA f) = + laurentLeftTuple K A hA f := by + rfl + +private theorem laurent_normalizedCoface_zero_at_pair + (hA : IsAffinoidAlgebra K A) (f : A) + (s : ((laurent K A f).cechFamily K A hA).NormalizedCochains 0) : + ((laurent K A f).cechFamily K A hA).normalizedCoface 0 0 s + (laurentPairTuple K A hA f) = + restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f)) + (s (laurentRightTuple K A hA f)) := by + change + (rationalPresheaf K A hA).restriction _ + (s (((laurent K A f).cechFamily K A hA).strictDelete 0 + (laurentPairTuple K A hA f))) = + _ + cases laurentPair_delete_zero K A hA f + rfl + +private theorem laurent_normalizedCoface_one_at_pair + (hA : IsAffinoidAlgebra K A) (f : A) + (s : ((laurent K A f).cechFamily K A hA).NormalizedCochains 0) : + ((laurent K A f).cechFamily K A hA).normalizedCoface 0 1 s + (laurentPairTuple K A hA f) = + restriction K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f)) + (s (laurentLeftTuple K A hA f)) := by + change + (rationalPresheaf K A hA).restriction _ + (s (((laurent K A f).cechFamily K A hA).strictDelete 1 + (laurentPairTuple K A hA f))) = + _ + cases laurentPair_delete_one K A hA f + rfl + +private noncomputable def laurentStandardOverlapCochainsEquiv + (hA : IsAffinoidAlgebra K A) (f : A) : + ((laurent K A f).cechFamily K A hA).NormalizedCochains 1 ≃ₗ[K] + (inter K A (laurentLE K A f) (laurentGE K A f)).Sections where + toFun s := s (laurentPairTuple K A hA f) + invFun x := by + intro σ + have hσ := laurentStrictTuple_one_eq_pair K A hA f σ + subst σ + exact x + left_inv s := by + funext σ + have hσ := laurentStrictTuple_one_eq_pair K A hA f σ + subst σ + rfl + right_inv _ := rfl + map_add' _ _ := rfl + map_smul' _ _ := rfl + +private noncomputable def laurentOverlapCochainsEquiv + (hA : IsAffinoidAlgebra K A) (f : A) : + ((laurent K A f).cechFamily K A hA).NormalizedCochains 1 ≃ₗ[K] + CompletedLaurent.LaurentIntersection K A f := by + change + ((laurent K A f).cechFamily K A hA).NormalizedCochains 1 ≃ₗ[K] + RationalLocalization K A 2 f + (CompletedLaurent.laurentIntersectionNumerator A f) + exact (laurentStandardOverlapCochainsEquiv K A hA f).trans + (sectionsLinearEquivOfCarrierEq K A hA + (inter K A (laurentLE K A f) (laurentGE K A f)) + (laurentIntersectionDomain K A f) + (carrier_inter_laurent_eq_laurentIntersectionDomain K A f)) + +private theorem laurent_normalizedAugmentation_comm + (hA : IsAffinoidAlgebra K A) (f : A) + (s : (whole K A).Sections) : + laurentChartCochainsEquiv K A hA f + (((laurent K A f).cechFamily K A hA).normalizedAugmentation s) = + LaurentCharts.diagonal K A f (wholeSectionsLinearEquiv K A hA s) := by + apply Prod.ext + · change + restriction K A hA + ((laurent K A f).subset (laurentLeftTuple K A hA f 0)) s = + LaurentCharts.plusMap K A f (wholeSectionsLinearEquiv K A hA s) + calc + _ = restriction K A hA + ((laurent K A f).subset (laurentLeftTuple K A hA f 0)) + ((wholeSectionsLinearEquiv K A hA).symm + (wholeSectionsLinearEquiv K A hA s)) := congrArg _ <| + (wholeSectionsLinearEquiv K A hA).symm_apply_apply s |>.symm + _ = _ := by + rw [wholeSectionsLinearEquiv_symm_apply] + exact congrArg + (fun φ : ContinuousAlgHom K A (laurentLE K A f).Sections ↦ + φ (wholeSectionsLinearEquiv K A hA s)) + (wholeToLeftRestriction_comp_baseMap K A hA f) + · change + restriction K A hA + ((laurent K A f).subset (laurentRightTuple K A hA f 0)) s = + LaurentCharts.minusMap K A f (wholeSectionsLinearEquiv K A hA s) + calc + _ = restriction K A hA + ((laurent K A f).subset (laurentRightTuple K A hA f 0)) + ((wholeSectionsLinearEquiv K A hA).symm + (wholeSectionsLinearEquiv K A hA s)) := congrArg _ <| + (wholeSectionsLinearEquiv K A hA).symm_apply_apply s |>.symm + _ = _ := by + rw [wholeSectionsLinearEquiv_symm_apply] + exact congrArg + (fun φ : ContinuousAlgHom K A (laurentGE K A f).Sections ↦ + φ (wholeSectionsLinearEquiv K A hA s)) + (wholeToRightRestriction_comp_baseMap K A hA f) + +private theorem laurent_normalizedDifferential_comm + (hA : IsAffinoidAlgebra K A) (f : A) + (s : ((laurent K A f).cechFamily K A hA).NormalizedCochains 0) : + laurentOverlapCochainsEquiv K A hA f + (((laurent K A f).cechFamily K A hA).normalizedCofaceModule.differential 0 s) = + -CompletedLaurent.directDifference K A f + (laurentChartCochainsEquiv K A hA f s) := by + rw [Cech.CofaceModule.differential, Fin.sum_univ_two] + simp only [Fin.val_zero, pow_zero, one_zsmul, Fin.val_one, pow_one, neg_zsmul, + one_zsmul, ModuleCat.hom_add, ModuleCat.hom_neg, ModuleCat.hom_ofHom, + LinearMap.add_apply, LinearMap.neg_apply] + change + standardOverlapToDirect K A hA f + ((((laurent K A f).cechFamily K A hA).normalizedCoface 0 0 s) + (laurentPairTuple K A hA f) + + -(((laurent K A f).cechFamily K A hA).normalizedCoface 0 1 s) + (laurentPairTuple K A hA f)) = + -CompletedLaurent.directDifference K A f + (laurentChartCochainsEquiv K A hA f s) + rw [laurent_normalizedCoface_zero_at_pair K A hA f, + laurent_normalizedCoface_one_at_pair K A hA f] + change + standardOverlapToDirect K A hA f + (restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f)) + (s (laurentRightTuple K A hA f)) + + -restriction K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f)) + (s (laurentLeftTuple K A hA f))) = + -CompletedLaurent.directDifference K A f + (s (laurentLeftTuple K A hA f), s (laurentRightTuple K A hA f)) + rw [CompletedLaurent.directDifference_apply, map_add, map_neg] + have hminus : + standardOverlapToDirect K A hA f + (restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f)) + (s (laurentRightTuple K A hA f))) = + CompletedLaurent.minusToLaurentIntersection K A f + (s (laurentRightTuple K A hA f)) := by + have h := congrArg + (fun φ : ContinuousAlgHom K (LaurentCharts.Minus K A f) + (CompletedLaurent.LaurentIntersection K A f) ↦ + φ (s (laurentRightTuple K A hA f))) + (standardOverlapToDirect_comp_minusRestriction K A hA f) + change + standardOverlapToDirect K A hA f + (restriction K A hA + (inter_subset_right K A (laurentLE K A f) (laurentGE K A f)) + (s (laurentRightTuple K A hA f))) = + CompletedLaurent.minusToLaurentIntersection K A f + (s (laurentRightTuple K A hA f)) at h + exact h + have hplus : + standardOverlapToDirect K A hA f + (restriction K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f)) + (s (laurentLeftTuple K A hA f))) = + CompletedLaurent.plusToLaurentIntersection K A f + (s (laurentLeftTuple K A hA f)) := by + have h := congrArg + (fun φ : ContinuousAlgHom K (LaurentCharts.Plus K A f) + (CompletedLaurent.LaurentIntersection K A f) ↦ + φ (s (laurentLeftTuple K A hA f))) + (standardOverlapToDirect_comp_plusRestriction K A hA f) + change + standardOverlapToDirect K A hA f + (restriction K A hA + (inter_subset_left K A (laurentLE K A f) (laurentGE K A f)) + (s (laurentLeftTuple K A hA f))) = + CompletedLaurent.plusToLaurentIntersection K A f + (s (laurentLeftTuple K A hA f)) at h + exact h + rw [hminus, hplus] + abel + +private theorem isEmpty_laurentStrictTuple + (hA : IsAffinoidAlgebra K A) (f : A) (n : ℕ) (hn : 2 ≤ n) : + IsEmpty (((laurent K A f).cechFamily K A hA).StrictTuple n) := by + constructor + intro σ + change Fin (n + 1) ↪o Fin 2 at σ + have hcard : n + 1 ≤ 2 := by + simpa using Fintype.card_le_of_injective σ σ.injective + omega + +/-- The normalized Čech complex of a two-member Laurent cover is acyclic. -/ +theorem laurent_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) (f : A) : + (laurent K A f).normalizedCechComplex K A hA |>.Acyclic := by + intro n + rcases n with _ | _ | _ | n + · rw [((laurent K A f).normalizedCechComplex K A hA).exactAt_iff' + 0 0 1 (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + change + ∀ x : (whole K A).Sections, + ((laurent K A f).cechFamily K A hA).normalizedAugmentation x = 0 → + ∃ y : (whole K A).Sections, 0 = x + intro x hx + have hdiag : + LaurentCharts.diagonal K A f (wholeSectionsLinearEquiv K A hA x) = 0 := by + have h := congrArg (laurentChartCochainsEquiv K A hA f) hx + rw [laurent_normalizedAugmentation_comm K A hA f] at h + simpa only [map_zero] using h + have hx0 : x = 0 := by + apply (wholeSectionsLinearEquiv K A hA).injective + apply (CompletedLaurent.direct_shortExact K A hA f).1 + exact hdiag.trans (by simp only [map_zero]) + subst x + exact ⟨0, by simp⟩ + · rw [((laurent K A f).normalizedCechComplex K A hA).exactAt_iff' + 0 1 2 (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + change + ∀ x : ((laurent K A f).cechFamily K A hA).NormalizedCochains 0, + ((laurent K A f).cechFamily K A hA).normalizedCofaceModule.differential 0 x = + 0 → + ∃ y : (whole K A).Sections, + ((laurent K A f).cechFamily K A hA).normalizedAugmentation y = x + intro x hx + change + ((laurent K A f).cechFamily K A hA).normalizedCofaceModule.differential 0 x = + (0 : ((laurent K A f).cechFamily K A hA).NormalizedCochains 1) at hx + have hdiff : + CompletedLaurent.directDifference K A f + (laurentChartCochainsEquiv K A hA f x) = 0 := by + have h := congrArg (laurentOverlapCochainsEquiv K A hA f) hx + rw [laurent_normalizedDifferential_comm K A hA f] at h + have hzero : + laurentOverlapCochainsEquiv K A hA f 0 = 0 := + map_zero (laurentOverlapCochainsEquiv K A hA f) + rw [hzero] at h + exact neg_eq_zero.mp h + obtain ⟨a, ha⟩ := + ((CompletedLaurent.direct_shortExact K A hA f).2.1 + (laurentChartCochainsEquiv K A hA f x)).mp hdiff + refine ⟨(wholeSectionsLinearEquiv K A hA).symm a, ?_⟩ + apply (laurentChartCochainsEquiv K A hA f).injective + rw [laurent_normalizedAugmentation_comm K A hA f] + simpa only [LinearEquiv.apply_symm_apply] using ha + · rw [((laurent K A f).normalizedCechComplex K A hA).exactAt_iff' + 1 2 3 (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + change + ∀ x : ((laurent K A f).cechFamily K A hA).NormalizedCochains 1, + _ → ∃ y : ((laurent K A f).cechFamily K A hA).NormalizedCochains 0, + ((laurent K A f).cechFamily K A hA).normalizedCofaceModule.differential 0 y = + x + intro x _ + obtain ⟨pq, hpq⟩ := + (CompletedLaurent.direct_shortExact K A hA f).2.2 + (laurentOverlapCochainsEquiv K A hA f x) + refine ⟨(laurentChartCochainsEquiv K A hA f).symm (-pq), ?_⟩ + apply (laurentOverlapCochainsEquiv K A hA f).injective + rw [laurent_normalizedDifferential_comm K A hA f] + simp only [LinearEquiv.apply_symm_apply, map_neg, neg_neg] + exact hpq + · apply HomologicalComplex.ExactAt.of_isZero + change CategoryTheory.Limits.IsZero + (ModuleCat.of K + (((laurent K A f).cechFamily K A hA).NormalizedCochains (n + 2))) + letI : IsEmpty + (((laurent K A f).cechFamily K A hA).StrictTuple (n + 2)) := + isEmpty_laurentStrictTuple K A hA f (n + 2) (by omega) + letI : Subsingleton + (((laurent K A f).cechFamily K A hA).NormalizedCochains (n + 2)) := + inferInstance + exact ModuleCat.isZero_of_subsingleton _ + +end Cover + +end AffinoidRationalSubdomain + +end Rigid diff --git a/Rigid/AffinoidSpectrum/LaurentProduct.lean b/Rigid/AffinoidSpectrum/LaurentProduct.lean new file mode 100644 index 0000000..467ab51 --- /dev/null +++ b/Rigid/AffinoidSpectrum/LaurentProduct.lean @@ -0,0 +1,286 @@ +import Rigid.AffinoidSpectrum.CoverProduct +import Rigid.AffinoidSpectrum.LaurentRestriction + +set_option linter.style.header false + +/-! +# Finite Laurent product covers + +A Laurent cover generated by finitely many functions is the iterated product of their +two-member Laurent covers. BGR 8.2.3 reduces its acyclicity to the one-function case using +product-cover comparison. This file carries out that induction. +-/ + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +/-- The Laurent cover generated by `f` followed by the functions in `fs`. -/ +noncomputable def laurentProduct (f : A) : + List A → Cover K A (whole K A) + | [] => laurent K A f + | g :: gs => product K A (laurentProduct f gs) (laurent K A g) + +/-- Every finite nonempty Laurent product cover is acyclic. -/ +theorem laurentProduct_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) (f : A) : + ∀ fs : List A, + (laurentProduct K A f fs).normalizedCechComplex K A hA |>.Acyclic + | [] => laurent_normalizedCechComplex_acyclic K A hA f + | g :: gs => by + apply + (product_normalizedCechComplex_acyclic_iff_left K A hA + (laurentProduct K A f gs) (laurent K A g) ?_).2 + · exact laurentProduct_normalizedCechComplex_acyclic hA f gs + · intro p σ + exact restrictTo_laurent_normalizedCechComplex_acyclic K A hA + ((laurentProduct K A f gs).cechFamily K A hA |>.tupleInter p σ) g + +/-- A chart of a finite Laurent product makes one fixed choice of sign for every +generating function. -/ +theorem laurentProduct_domain_sign_of_mem (f : A) : + ∀ (fs : List A) (g : A), g = f ∨ g ∈ fs → + ∀ i : Fin (laurentProduct K A f fs).m, + (∀ x ∈ ((laurentProduct K A f fs).domain i).carrier, x g ≤ 1) ∨ + (∀ x ∈ ((laurentProduct K A f fs).domain i).carrier, 1 ≤ x g) + | [], g, hg, i => by + have hgf : g = f := hg.resolve_right (by simp) + subst g + change Fin 2 at i + fin_cases i + · left + intro x hx + exact (mem_carrier_laurentLE K A f x).1 hx + · right + intro x hx + exact (mem_carrier_laurentGE K A f x).1 hx + | g₀ :: gs, g, hg, i => by + let 𝒰 := laurentProduct K A f gs + let 𝒱 := laurent K A g₀ + let ij := productPair K A 𝒰 𝒱 i + rcases hg with hgf | hglist + · obtain hsign := + laurentProduct_domain_sign_of_mem f gs g (Or.inl hgf) ij.1 + exact hsign.imp + (fun h x hx ↦ h x (inter_subset_left K A _ _ hx)) + (fun h x hx ↦ h x (inter_subset_left K A _ _ hx)) + · rcases List.mem_cons.mp hglist with hg₀ | hgs + · rw [hg₀] + have hright : + (∀ x ∈ (𝒱.domain ij.2).carrier, x g₀ ≤ 1) ∨ + (∀ x ∈ (𝒱.domain ij.2).carrier, 1 ≤ x g₀) := by + refine Fin.cases ?_ (fun j ↦ ?_) ij.2 + · left + intro x hx + exact (mem_carrier_laurentLE K A g₀ x).1 hx + · have hj : j = 0 := Fin.eq_zero j + subst j + right + intro x hx + exact (mem_carrier_laurentGE K A g₀ x).1 hx + exact hright.imp + (fun h x hx ↦ h x (inter_subset_right K A _ _ hx)) + (fun h x hx ↦ h x (inter_subset_right K A _ _ hx)) + · obtain hsign := + laurentProduct_domain_sign_of_mem f gs g (Or.inr hgs) ij.1 + exact hsign.imp + (fun h x hx ↦ h x (inter_subset_left K A _ _ hx)) + (fun h x hx ↦ h x (inter_subset_left K A _ _ hx)) + +private noncomputable abbrev mapToSections + (W : AffinoidRationalSubdomain K A) (f : A) : W.Sections := + RationalLocalization.baseMap K A W.n W.g W.f f + +private noncomputable def mappedLaurentProduct + (W : AffinoidRationalSubdomain K A) (f : A) : + List A → Cover K W.Sections (whole K W.Sections) + | [] => laurent K W.Sections (mapToSections K A W f) + | g :: gs => + product K W.Sections (mappedLaurentProduct W f gs) + (laurent K W.Sections (mapToSections K A W g)) + +/-- The recursively induced identification of the chart indices before and after applying +the restriction map. -/ +private noncomputable def mappedLaurentProductIndexEquiv + (W : AffinoidRationalSubdomain K A) (f : A) : + ∀ fs : List A, + Fin (laurentProduct K A f fs).m ≃ Fin (mappedLaurentProduct K A W f fs).m + | [] => Equiv.refl _ + | g :: gs => by + let 𝒰 := laurentProduct K A f gs + let 𝒱 := laurent K A g + let 𝒰' := mappedLaurentProduct K A W f gs + let 𝒱' := laurent K W.Sections (mapToSections K A W g) + let e := mappedLaurentProductIndexEquiv W f gs + exact + { toFun := fun i ↦ + productIndex K W.Sections 𝒰' 𝒱' + (e (productPair K A 𝒰 𝒱 i).1, (productPair K A 𝒰 𝒱 i).2) + invFun := fun i ↦ + productIndex K A 𝒰 𝒱 + (e.symm (productPair K W.Sections 𝒰' 𝒱' i).1, + (productPair K W.Sections 𝒰' 𝒱' i).2) + left_inv := by + intro i + simp only [productPair_productIndex, Equiv.symm_apply_apply] + exact productIndex_productPair K A 𝒰 𝒱 i + right_inv := by + intro i + simp only [productPair_productIndex, Equiv.apply_symm_apply] + exact productIndex_productPair K W.Sections 𝒰' 𝒱' i } + +@[simp] +private theorem mappedLaurentProductIndexEquiv_cons_productIndex + (W : AffinoidRationalSubdomain K A) (f g : A) (gs : List A) + (ij : ProductIndex K A (laurentProduct K A f gs) (laurent K A g)) : + mappedLaurentProductIndexEquiv K A W f (g :: gs) + (productIndex K A (laurentProduct K A f gs) (laurent K A g) ij) = + productIndex K W.Sections + (mappedLaurentProduct K A W f gs) + (laurent K W.Sections (mapToSections K A W g)) + (mappedLaurentProductIndexEquiv K A W f gs ij.1, ij.2) := by + change + productIndex K W.Sections + (mappedLaurentProduct K A W f gs) + (laurent K W.Sections (mapToSections K A W g)) + (mappedLaurentProductIndexEquiv K A W f gs + (productPair K A (laurentProduct K A f gs) (laurent K A g) + (productIndex K A (laurentProduct K A f gs) (laurent K A g) ij)).1, + (productPair K A (laurentProduct K A f gs) (laurent K A g) + (productIndex K A (laurentProduct K A f gs) (laurent K A g) ij)).2) = + _ + rw [productPair_productIndex] + +/-- The finite Laurent product after applying the restriction map is acyclic. This +definition follows the original list, rather than the mapped list, so its chart index +type is definitionally the same as that of the original Laurent product. -/ +private theorem mappedLaurentProduct_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) + (W : AffinoidRationalSubdomain K A) (f : A) : + ∀ fs : List A, + (mappedLaurentProduct K A W f fs).normalizedCechComplex K W.Sections + (isAffinoidAlgebra_sections K A hA W) |>.Acyclic + | [] => + laurent_normalizedCechComplex_acyclic K W.Sections + (isAffinoidAlgebra_sections K A hA W) (mapToSections K A W f) + | g :: gs => by + apply + (product_normalizedCechComplex_acyclic_iff_left K W.Sections + (isAffinoidAlgebra_sections K A hA W) + (mappedLaurentProduct K A W f gs) + (laurent K W.Sections (mapToSections K A W g)) ?_).2 + · exact mappedLaurentProduct_normalizedCechComplex_acyclic hA W f gs + · intro p σ + exact restrictTo_laurent_normalizedCechComplex_acyclic K W.Sections + (isAffinoidAlgebra_sections K A hA W) + ((mappedLaurentProduct K A W f gs).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W) |>.tupleInter p σ) + (mapToSections K A W g) + +/-- Restricting and rebasing a finite Laurent product gives the same chart carriers as the +finite Laurent product of the restricted functions. -/ +theorem rebase_restrictTo_laurentProduct_domain_carrier_eq + (W : AffinoidRationalSubdomain K A) (f : A) : + ∀ (fs : List A) + (i : Fin (laurentProduct K A f fs).m), + (((laurentProduct K A f fs).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier)).rebase K A + |>.domain i).carrier = + (mappedLaurentProduct K A W f fs + |>.domain (mappedLaurentProductIndexEquiv K A W f fs i)).carrier + | [], i => rebase_restrictTo_laurent_domain_carrier_eq K A W f i + | g :: gs, i => by + let 𝒰 := laurentProduct K A f gs + let 𝒱 := laurent K A g + let ij := productPair K A 𝒰 𝒱 i + let e := mappedLaurentProductIndexEquiv K A W f gs + have htail := + rebase_restrictTo_laurentProduct_domain_carrier_eq W f gs ij.1 + have hg := + rebase_restrictTo_laurent_domain_carrier_eq K A W g ij.2 + have hi : productIndex K A 𝒰 𝒱 ij = i := + productIndex_productPair K A 𝒰 𝒱 i + rw [← hi] + rw [mappedLaurentProductIndexEquiv_cons_productIndex] + ext y + dsimp only [laurentProduct, mappedLaurentProduct] + have hp : + productPair K A (laurentProduct K A f gs) (laurent K A g) + (productIndex K A 𝒰 𝒱 ij) = ij := by + simpa only [𝒰, 𝒱] using productPair_productIndex K A 𝒰 𝒱 ij + rw [hp] + have hp' : + productPair K W.Sections + (mappedLaurentProduct K A W f gs) + (laurent K W.Sections (mapToSections K A W g)) + (productIndex K W.Sections + (mappedLaurentProduct K A W f gs) + (laurent K W.Sections (mapToSections K A W g)) + (e ij.1, ij.2)) = + (e ij.1, ij.2) := + productPair_productIndex K W.Sections + (mappedLaurentProduct K A W f gs) + (laurent K W.Sections (mapToSections K A W g)) _ + rw [hp'] + have htail_y := Set.ext_iff.mp htail y + have hg_y := Set.ext_iff.mp hg y + rw [mem_rebase_carrier_iff, carrier_inter, Set.mem_inter_iff] at htail_y hg_y + rw [mem_rebase_carrier_iff] + simp only [carrier_inter, Set.mem_inter_iff] + constructor + · rintro ⟨hyW, hy𝒰, hy𝒱⟩ + exact ⟨htail_y.1 ⟨hyW, hy𝒰⟩, hg_y.1 ⟨hyW, hy𝒱⟩⟩ + · rintro ⟨hy𝒰, hy𝒱⟩ + have hyW := ambientPoint_mem_carrier K A W y + exact ⟨hyW, (htail_y.2 hy𝒰).2, (hg_y.2 hy𝒱).2⟩ + +private noncomputable def rebaseRestrictLaurentProductRefinement + (W : AffinoidRationalSubdomain K A) (f : A) (fs : List A) : + Refinement K W.Sections + (((laurentProduct K A f fs).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier)).rebase K A) + (mappedLaurentProduct K A W f fs) where + index := mappedLaurentProductIndexEquiv K A W f fs + subset i := + (rebase_restrictTo_laurentProduct_domain_carrier_eq K A W f fs i).le + +private noncomputable def laurentProductRefinementRebaseRestrict + (W : AffinoidRationalSubdomain K A) (f : A) (fs : List A) : + Refinement K W.Sections + (mappedLaurentProduct K A W f fs) + (((laurentProduct K A f fs).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier)).rebase K A) where + index := (mappedLaurentProductIndexEquiv K A W f fs).symm + subset i := by + simpa only [Equiv.apply_symm_apply] using + (rebase_restrictTo_laurentProduct_domain_carrier_eq K A W f fs + ((mappedLaurentProductIndexEquiv K A W f fs).symm i)).ge + +/-- Every finite Laurent product cover remains acyclic after restriction to a rational +subdomain. -/ +theorem restrictTo_laurentProduct_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) + (W : AffinoidRationalSubdomain K A) (f : A) (fs : List A) : + (((laurentProduct K A f fs).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier) + ).normalizedCechComplex K A hA).Acyclic := by + rw [normalizedCechComplex_acyclic_iff_rebase K A hA] + exact + (normalizedCechComplex_acyclic_iff_of_mutual_refinement K W.Sections + (isAffinoidAlgebra_sections K A hA W) + (((laurentProduct K A f fs).restrictTo K A W (by + simpa only [carrier_whole] using Set.subset_univ W.carrier)).rebase K A) + (mappedLaurentProduct K A W f fs) + (laurentProductRefinementRebaseRestrict K A W f fs) + (rebaseRestrictLaurentProductRefinement K A W f fs)).2 + (mappedLaurentProduct_normalizedCechComplex_acyclic K A hA W f fs) + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/LaurentRestriction.lean b/Rigid/AffinoidSpectrum/LaurentRestriction.lean new file mode 100644 index 0000000..d8f114d --- /dev/null +++ b/Rigid/AffinoidSpectrum/LaurentRestriction.lean @@ -0,0 +1,254 @@ +import Rigid.AffinoidSpectrum.CechRebase +import Rigid.AffinoidSpectrum.CechRestriction +import Rigid.AffinoidSpectrum.LaurentCech + +set_option linter.style.header false + +/-! +# Laurent covers restricted to rational subdomains + +The restriction of the two-member Laurent cover associated with `f : A` to a rational subdomain +`W` becomes, after rebasing to `W.Sections`, the ordinary Laurent cover associated with the image +of `f`. Hence every such restricted cover is acyclic. +-/ + +open CategoryTheory + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +variable (hA : IsAffinoidAlgebra K A) + +private noncomputable abbrev restrictedLaurent + (W : AffinoidRationalSubdomain K A) (f : A) : + Cover K A W := + (laurent K A f).restrictTo K A W (by + rw [carrier_whole] + exact Set.subset_univ _) + +private noncomputable abbrev rebasedRestrictedLaurent + (W : AffinoidRationalSubdomain K A) (f : A) : + Cover K W.Sections (whole K W.Sections) := + (restrictedLaurent K A W f).rebase K A + +private noncomputable abbrev restrictedElement + (W : AffinoidRationalSubdomain K A) (f : A) : W.Sections := + RationalLocalization.baseMap K A W.n W.g W.f f + +/-- After restricting and rebasing a Laurent cover, each member has the same carrier as the +corresponding standard Laurent chart over the section algebra. -/ +theorem rebase_restrictTo_laurent_domain_carrier_eq + (W : AffinoidRationalSubdomain K A) (f : A) (i : Fin 2) : + ((((laurent K A f).restrictTo K A W (by + rw [carrier_whole] + exact Set.subset_univ _)).rebase K A).domain i).carrier = + ((laurent K W.Sections + (RationalLocalization.baseMap K A W.n W.g W.f f)).domain i).carrier := by + ext y + fin_cases i + · rw [mem_rebase_carrier_iff] + change + ambientPoint K A W y ∈ (inter K A W (laurentLE K A f)).carrier ↔ + y ∈ (laurentLE K W.Sections (restrictedElement K A W f)).carrier + rw [carrier_inter, Set.mem_inter_iff, mem_carrier_laurentLE, + mem_carrier_laurentLE, ← ambientPoint_apply K A W] + constructor + · exact And.right + · exact fun h ↦ ⟨ambientPoint_mem_carrier K A W y, h⟩ + · rw [mem_rebase_carrier_iff] + change + ambientPoint K A W y ∈ (inter K A W (laurentGE K A f)).carrier ↔ + y ∈ (laurentGE K W.Sections (restrictedElement K A W f)).carrier + rw [carrier_inter, Set.mem_inter_iff, mem_carrier_laurentGE, + mem_carrier_laurentGE, ← ambientPoint_apply K A W] + constructor + · exact And.right + · exact fun h ↦ ⟨ambientPoint_mem_carrier K A W y, h⟩ + +private theorem rebasedRestrictedLaurent_tupleInter_carrier_eq + (W : AffinoidRationalSubdomain K A) (f : A) (n : ℕ) + (τ : ((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).StrictTuple n) : + (((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).tupleInter n τ).carrier = + (((laurent K W.Sections (restrictedElement K A W f)).cechFamily + K W.Sections (isAffinoidAlgebra_sections K A hA W)).tupleInter n τ).carrier := by + induction n with + | zero => + exact rebase_restrictTo_laurent_domain_carrier_eq K A W f (τ 0) + | succ n ih => + rw [Cech.Presheaf.Family.tupleInter, Cech.Presheaf.Family.tupleInter, + carrier_inter, carrier_inter] + let τ₀ : + ((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).StrictTuple n := + Fin.castSuccOrderEmb.comp τ + have hi := ih τ₀ + change + (((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).tupleInter n + (fun i ↦ τ i.castSucc)).carrier = + (((laurent K W.Sections (restrictedElement K A W f)).cechFamily + K W.Sections (isAffinoidAlgebra_sections K A hA W)).tupleInter n + (fun i ↦ τ i.castSucc)).carrier at hi + rw [hi, rebase_restrictTo_laurent_domain_carrier_eq K A W f] + +private noncomputable def rebasedRestrictedLaurentTupleSectionsLinearEquiv + (W : AffinoidRationalSubdomain K A) (f : A) (n : ℕ) + (τ : ((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).StrictTuple n) : + (((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).tupleInter n τ).Sections ≃ₗ[K] + (((laurent K W.Sections (restrictedElement K A W f)).cechFamily + K W.Sections (isAffinoidAlgebra_sections K A hA W)).tupleInter n τ).Sections := + sectionsLinearEquivOfCarrierEq K W.Sections + (isAffinoidAlgebra_sections K A hA W) _ _ + (rebasedRestrictedLaurent_tupleInter_carrier_eq K A hA W f n τ) + +set_option synthInstance.maxHeartbeats 100000 in +-- Dependent products of rational-localization section modules make instance synthesis deep. +private noncomputable def rebasedRestrictedLaurentCochainsLinearEquiv + (W : AffinoidRationalSubdomain K A) (f : A) (n : ℕ) : + ((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).NormalizedCochains n ≃ₗ[K] + ((laurent K W.Sections (restrictedElement K A W f)).cechFamily + K W.Sections + (isAffinoidAlgebra_sections K A hA W)).NormalizedCochains n := + LinearEquiv.piCongrRight (R := K) fun τ ↦ + rebasedRestrictedLaurentTupleSectionsLinearEquiv K A hA W f n τ + +set_option synthInstance.maxHeartbeats 100000 in +-- The normalized cochain module is a dependent product of localization modules. +private theorem rebasedRestrictedLaurent_augmentation_comm + (W : AffinoidRationalSubdomain K A) (f : A) : + (rebasedRestrictedLaurentCochainsLinearEquiv K A hA W f 0).toLinearMap.comp + ((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).normalizedAugmentation = + ((laurent K W.Sections (restrictedElement K A W f)).cechFamily + K W.Sections + (isAffinoidAlgebra_sections K A hA W)).normalizedAugmentation := by + apply LinearMap.ext + intro s + funext τ + change + restriction K W.Sections (isAffinoidAlgebra_sections K A hA W) _ + (restriction K W.Sections (isAffinoidAlgebra_sections K A hA W) _ s) = + restriction K W.Sections (isAffinoidAlgebra_sections K A hA W) _ s + rw [← ContinuousAlgHom.comp_apply, restriction_comp] + +set_option maxHeartbeats 800000 in +-- Unfolding both carrier-equivalent localization complexes is elaboration-intensive. +set_option synthInstance.maxHeartbeats 100000 in +-- Their cochain modules are dependent products of rational-localization section modules. +private theorem rebasedRestrictedLaurent_coface_comm + (W : AffinoidRationalSubdomain K A) (f : A) + (n : ℕ) (i : Fin (n + 2)) : + (rebasedRestrictedLaurentCochainsLinearEquiv K A hA W f (n + 1)).toLinearMap.comp + (((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).normalizedCoface n i) = + (((laurent K W.Sections (restrictedElement K A W f)).cechFamily + K W.Sections + (isAffinoidAlgebra_sections K A hA W)).normalizedCoface n i).comp + (rebasedRestrictedLaurentCochainsLinearEquiv K A hA W f n).toLinearMap := by + apply LinearMap.ext + intro s + funext τ + change + restriction K W.Sections (isAffinoidAlgebra_sections K A hA W) _ + (restriction K W.Sections (isAffinoidAlgebra_sections K A hA W) _ + (s (i.succAboveOrderEmb.comp τ))) = + restriction K W.Sections (isAffinoidAlgebra_sections K A hA W) _ + (restriction K W.Sections (isAffinoidAlgebra_sections K A hA W) _ + (s (i.succAboveOrderEmb.comp τ))) + rw [← ContinuousAlgHom.comp_apply, restriction_comp, + ← ContinuousAlgHom.comp_apply, restriction_comp] + +set_option synthInstance.maxHeartbeats 100000 in +-- The explicit scalar ring prevents synthesis from exploring localization algebra structures. +private noncomputable def rebasedRestrictedLaurentCochainsModuleIso + (W : AffinoidRationalSubdomain K A) (f : A) (n : ℕ) : + ((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).normalizedCofaceModule.X n ≅ + ((laurent K W.Sections (restrictedElement K A W f)).cechFamily + K W.Sections + (isAffinoidAlgebra_sections K A hA W)).normalizedCofaceModule.X n := + (rebasedRestrictedLaurentCochainsLinearEquiv K A hA W f n).toModuleIso + +set_option synthInstance.maxHeartbeats 100000 in +-- Alternating sums retain the dependent-product module structure during elaboration. +private theorem rebasedRestrictedLaurent_differential_comm + (W : AffinoidRationalSubdomain K A) (f : A) (n : ℕ) : + ((rebasedRestrictedLaurent K A W f).cechFamily K W.Sections + (isAffinoidAlgebra_sections K A hA W)).normalizedCofaceModule.differential n ≫ + (rebasedRestrictedLaurentCochainsModuleIso K A hA W f (n + 1)).hom = + (rebasedRestrictedLaurentCochainsModuleIso K A hA W f n).hom ≫ + ((laurent K W.Sections (restrictedElement K A W f)).cechFamily + K W.Sections + (isAffinoidAlgebra_sections K A hA W)).normalizedCofaceModule.differential n := by + simp only [Cech.CofaceModule.differential, + CategoryTheory.Preadditive.sum_comp, CategoryTheory.Preadditive.zsmul_comp] + rw [CategoryTheory.Preadditive.comp_sum] + simp only [CategoryTheory.Preadditive.comp_zsmul] + apply Finset.sum_congr rfl + intro i _ + congr 1 + apply ModuleCat.hom_ext + exact rebasedRestrictedLaurent_coface_comm K A hA W f n i + +set_option synthInstance.maxHeartbeats 100000 in +-- Components in positive degree are dependent products of section modules. +private noncomputable abbrev rebasedRestrictedLaurentComponentIso + (W : AffinoidRationalSubdomain K A) (f : A) : + ∀ n, ( + ((rebasedRestrictedLaurent K A W f).normalizedCechComplex K W.Sections + (isAffinoidAlgebra_sections K A hA W)).X n ≅ + ((laurent K W.Sections (restrictedElement K A W f)).normalizedCechComplex + K W.Sections (isAffinoidAlgebra_sections K A hA W)).X n) + | 0 => Iso.refl _ + | n + 1 => rebasedRestrictedLaurentCochainsModuleIso K A hA W f n + +set_option synthInstance.maxHeartbeats 100000 in +-- Constructing the chain isomorphism elaborates all dependent-product components. +private noncomputable def rebasedRestrictedLaurentCechIso + (W : AffinoidRationalSubdomain K A) (f : A) : + (rebasedRestrictedLaurent K A W f).normalizedCechComplex K W.Sections + (isAffinoidAlgebra_sections K A hA W) ≅ + (laurent K W.Sections (restrictedElement K A W f)).normalizedCechComplex + K W.Sections (isAffinoidAlgebra_sections K A hA W) := + HomologicalComplex.Hom.isoOfComponents + (rebasedRestrictedLaurentComponentIso K A hA W f) + (by + intro i j hij + simp only [ComplexShape.up_Rel] at hij + subst j + dsimp only [normalizedCechComplex] + cases i with + | zero => + apply ModuleCat.hom_ext + exact (rebasedRestrictedLaurent_augmentation_comm K A hA W f).symm + | succ n => + simpa only [Cech.CofaceModule.Augmented.complex, + CochainComplex.of_d, Cech.CofaceModule.Augmented.differential, + rebasedRestrictedLaurentComponentIso] using + (rebasedRestrictedLaurent_differential_comm K A hA W f n).symm) + +/-- The restriction of a two-member Laurent cover to any rational subdomain is acyclic. -/ +theorem restrictTo_laurent_normalizedCechComplex_acyclic + (W : AffinoidRationalSubdomain K A) (f : A) : + ((restrictedLaurent K A W f).normalizedCechComplex K A hA).Acyclic := by + rw [normalizedCechComplex_acyclic_iff_rebase K A hA] + intro n + exact (laurent_normalizedCechComplex_acyclic K W.Sections + (isAffinoidAlgebra_sections K A hA W) (restrictedElement K A W f) n).of_iso + (rebasedRestrictedLaurentCechIso K A hA W f).symm + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/RationalPresheaf.lean b/Rigid/AffinoidSpectrum/RationalPresheaf.lean new file mode 100644 index 0000000..ea349c8 --- /dev/null +++ b/Rigid/AffinoidSpectrum/RationalPresheaf.lean @@ -0,0 +1,176 @@ +import Rigid.AffinoidAlgebra.BanachRealization +import Rigid.AffinoidAlgebra.SpectralPresentation +import Rigid.AffinoidSpectrum.RationalCover +import Rigid.AffinoidSpectrum.Restriction + +set_option linter.style.header false + +/-! +# The rational-localization presheaf + +This file makes the restriction map between arbitrary rational subdomains unconditional for an +affinoid ambient algebra. It packages the spectral-criterion argument already used in the +comparator and proves identity and composition, which are the functoriality facts needed by Čech +complexes. +-/ + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain + +/-- Restriction of analytic functions along an inclusion of rational subdomains. -/ +noncomputable def restriction (hA : IsAffinoidAlgebra K A) + {U V : AffinoidRationalSubdomain K A} + (hUV : U.carrier ⊆ V.carrier) : ContinuousAlgHom K V.Sections U.Sections := by + by_cases hU : Nontrivial U.Sections + · letI := hU + have hAtop : (inferInstance : TopologicalSpace A) = + affinoidTopology K A hA := + topology_eq_affinoidTopology_of_presentation K A + hA.presentation.n hA.presentation.ideal hA.presentation.equiv + let π : ContinuousAlgHom K (TateAlgebra K (Fin hA.presentation.n)) A := + { toAlgHom := hA.presentation.toAlgHom + cont := continuous_tateAlgebra_to_affinoid K hA hAtop hA.presentation.toAlgHom } + let hUaff := isAffinoidAlgebra_rationalLocalization_of_surjective + K A hA.presentation.n π hA.presentation.toAlgHom_surjective U.n U.g U.f + let P := hUaff.presentation + have htop : (inferInstance : TopologicalSpace U.Sections) = P.residueTopology := by + exact topology_eq_affinoidTopology_of_presentation K U.Sections + P.n P.ideal P.equiv + exact restrictionOfSpectralCriterion K A hUV + (SpectralPolynomial.hasPowerBoundedSpectralCriterion_of_affinoidPresentation + K P htop) + · letI : Subsingleton U.Sections := not_nontrivial_iff_subsingleton.mp hU + exact restrictionOfPointwisePowerBounded K A hUV fun i ↦ by + rw [Subsingleton.elim + (RationalLocalization.quotientCoordinate K A + (f := V.f) + (RationalLocalization.baseMap K A U.n U.g U.f) + (isUnit_baseMap_denominator_of_subset K A hUV) i) 0] + exact isPowerBounded_zero + +@[simp] +theorem restriction_id (hA : IsAffinoidAlgebra K A) (U : AffinoidRationalSubdomain K A) : + restriction K A hA (U := U) (V := U) Set.Subset.rfl = + ContinuousAlgHom.id K U.Sections := by + unfold restriction + dsimp only + split + · apply restrictionOfPointwisePowerBounded_id + · apply restrictionOfPointwisePowerBounded_id + +@[simp] +theorem restriction_comp (hA : IsAffinoidAlgebra K A) + {U V W : AffinoidRationalSubdomain K A} + (hUV : U.carrier ⊆ V.carrier) (hWU : W.carrier ⊆ U.carrier) : + (restriction K A hA hWU).comp (restriction K A hA hUV) = + restriction K A hA (hWU.trans hUV) := by + unfold restriction + dsimp only + repeat' split + all_goals + try unfold restrictionOfSpectralCriterion + apply restrictionOfPointwisePowerBounded_comp + +/-- Restriction to a rational subdomain agrees with its canonical base map on ambient +functions. -/ +@[simp] +theorem restriction_comp_baseMap (hA : IsAffinoidAlgebra K A) + {U V : AffinoidRationalSubdomain K A} + (hUV : U.carrier ⊆ V.carrier) : + (restriction K A hA hUV).comp + (RationalLocalization.baseMap K A V.n V.g V.f) = + RationalLocalization.baseMap K A U.n U.g U.f := by + unfold restriction + dsimp only + split + · apply restrictionOfPointwisePowerBounded_comp_baseMap + · apply restrictionOfPointwisePowerBounded_comp_baseMap + +/-- Two rational data cutting out the same point set have canonically linearly equivalent +section algebras. -/ +noncomputable def sectionsLinearEquivOfCarrierEq (hA : IsAffinoidAlgebra K A) + (U V : AffinoidRationalSubdomain K A) (hUV : U.carrier = V.carrier) : + U.Sections ≃ₗ[K] V.Sections where + toFun := restriction K A hA hUV.ge + invFun := restriction K A hA hUV.le + left_inv x := by + have hcomp := restriction_comp K A hA hUV.ge hUV.le + have hid := restriction_id K A hA U + exact congrArg (fun φ : ContinuousAlgHom K U.Sections U.Sections ↦ φ x) + (hcomp.trans hid) + right_inv x := by + have hcomp := restriction_comp K A hA hUV.le hUV.ge + have hid := restriction_id K A hA V + exact congrArg (fun φ : ContinuousAlgHom K V.Sections V.Sections ↦ φ x) + (hcomp.trans hid) + map_add' x y := map_add _ x y + map_smul' c x := map_smul _ c x + +/-- Evaluation identifies the section algebra of the whole rational subdomain with the ambient +algebra. -/ +noncomputable def wholeSectionsLinearEquiv (hA : IsAffinoidAlgebra K A) : + (whole K A).Sections ≃ₗ[K] A := by + change RationalLocalization K A 0 1 Fin.elim0 ≃ₗ[K] A + let ev : ContinuousAlgHom K (RationalLocalization K A 0 1 Fin.elim0) A := + RationalLocalization.lift K A 0 1 Fin.elim0 + (ContinuousAlgHom.id K A) Fin.elim0 + (fun i ↦ Fin.elim0 i) (fun i ↦ Fin.elim0 i) + let base : ContinuousAlgHom K A (RationalLocalization K A 0 1 Fin.elim0) := + RationalLocalization.baseMap K A 0 1 Fin.elim0 + refine + { toFun := ev + invFun := base + left_inv := ?_ + right_inv := ?_ + map_add' := fun x y ↦ map_add ev x y + map_smul' := fun c x ↦ map_smul ev c x } + · intro x + have hevbase : ev.comp base = ContinuousAlgHom.id K A := by + change + (RationalLocalization.lift K A 0 1 Fin.elim0 + (ContinuousAlgHom.id K A) Fin.elim0 + (fun i ↦ Fin.elim0 i) (fun i ↦ Fin.elim0 i)).comp + (RationalLocalization.baseMap K A 0 1 Fin.elim0) = + ContinuousAlgHom.id K A + exact RationalLocalization.lift_comp_baseMap K A 0 1 Fin.elim0 + (ContinuousAlgHom.id K A) Fin.elim0 + (fun i ↦ Fin.elim0 i) (fun i ↦ Fin.elim0 i) + have hbaseev : base.comp ev = + ContinuousAlgHom.id K (RationalLocalization K A 0 1 Fin.elim0) := by + apply RationalLocalization.hom_ext K A 0 1 Fin.elim0 + · rw [ContinuousAlgHom.comp_assoc, hevbase, + ContinuousAlgHom.comp_id, ContinuousAlgHom.id_comp] + · intro i + exact Fin.elim0 i + exact congrArg (fun φ : ContinuousAlgHom K (RationalLocalization K A 0 1 Fin.elim0) + (RationalLocalization K A 0 1 Fin.elim0) ↦ φ x) hbaseev + · intro x + have hevbase : ev.comp base = ContinuousAlgHom.id K A := by + change + (RationalLocalization.lift K A 0 1 Fin.elim0 + (ContinuousAlgHom.id K A) Fin.elim0 + (fun i ↦ Fin.elim0 i) (fun i ↦ Fin.elim0 i)).comp + (RationalLocalization.baseMap K A 0 1 Fin.elim0) = + ContinuousAlgHom.id K A + exact RationalLocalization.lift_comp_baseMap K A 0 1 Fin.elim0 + (ContinuousAlgHom.id K A) Fin.elim0 + (fun i ↦ Fin.elim0 i) (fun i ↦ Fin.elim0 i) + exact congrArg (fun φ : ContinuousAlgHom K A A ↦ φ x) hevbase + +@[simp] +theorem wholeSectionsLinearEquiv_symm_apply (hA : IsAffinoidAlgebra K A) (x : A) : + (wholeSectionsLinearEquiv K A hA).symm x = + RationalLocalization.baseMap K A (whole K A).n (whole K A).g + (whole K A).f x := + rfl + +end AffinoidRationalSubdomain + +end Rigid diff --git a/Rigid/AffinoidSpectrum/RationalRebase.lean b/Rigid/AffinoidSpectrum/RationalRebase.lean new file mode 100644 index 0000000..1618225 --- /dev/null +++ b/Rigid/AffinoidSpectrum/RationalRebase.lean @@ -0,0 +1,468 @@ +import Rigid.AffinoidSpectrum.RationalCover +import Rigid.AffinoidSpectrum.RationalPresheaf +import Mathlib.RingTheory.Ideal.Maps + +set_option linter.style.header false + +/-! +# Rebasing rational domains to a rational subdomain + +If `V` is a rational subdomain of an affinoid algebra `A` and `U` is another rational subdomain, +the defining datum of `V` can be mapped to `U.Sections`. For `V ⊆ U`, its carrier is then the +pullback of `V` to the spectrum of `U.Sections`. Consequently, every rational cover of `U` +becomes a rational cover of the whole spectrum of `U.Sections`. + +This is the geometric rebasing step used in BGR 8.2.2 before applying the Laurent-cover argument +over the affinoid algebra of a member of a cover. +-/ + +universe u v w + +namespace Rigid + +/-- A unital ring homomorphism carries rational data to rational data. -/ +theorem IsRationalDatum.map + {R : Type v} {S : Type w} [CommRing R] [CommRing S] + {n : ℕ} {g : R} {f : Fin n → R} + (h : IsRationalDatum g f) (φ : R →+* S) : + IsRationalDatum (φ g) (fun i ↦ φ (f i)) := by + rw [IsRationalDatum] at h ⊢ + have hmap : + Ideal.map φ (Ideal.span (Set.insert g (Set.range f))) = ⊤ := by + rw [h, Ideal.map_top] + rw [Ideal.map_span] at hmap + have himage : + φ '' Set.insert g (Set.range f) = + Set.insert (φ g) (Set.range fun i ↦ φ (f i)) := by + ext x + constructor + · rintro ⟨a, (rfl | ⟨i, rfl⟩), rfl⟩ + · exact Set.mem_insert _ _ + · exact Set.mem_insert_of_mem _ ⟨i, rfl⟩ + · rintro (rfl | ⟨i, rfl⟩) + · exact ⟨g, Set.mem_insert _ _, rfl⟩ + · exact ⟨f i, Set.mem_insert_of_mem _ ⟨i, rfl⟩, rfl⟩ + rwa [himage] at hmap + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain + +/-- A rational datum on `A`, mapped to the section algebra of a rational subdomain `U`. -/ +noncomputable def rebase (U V : AffinoidRationalSubdomain K A) : + AffinoidRationalSubdomain K U.Sections where + n := V.n + g := RationalLocalization.baseMap K A U.n U.g U.f V.g + f i := RationalLocalization.baseMap K A U.n U.g U.f (V.f i) + isRational := V.isRational.map + (RationalLocalization.baseMap K A U.n U.g U.f).toRingHom + +@[simp] +theorem mem_rebase_carrier_iff (U V : AffinoidRationalSubdomain K A) + (y : BerkovichSpectrumOver K U.Sections) : + y ∈ (rebase K A U V).carrier ↔ + ambientPoint K A U y ∈ V.carrier := by + rfl + +/-- Rebasing preserves inclusions of rational subdomains. -/ +theorem rebase_carrier_subset + (U : AffinoidRationalSubdomain K A) + {V W : AffinoidRationalSubdomain K A} (hWV : W.carrier ⊆ V.carrier) : + (rebase K A U W).carrier ⊆ (rebase K A U V).carrier := by + intro y hy + exact (mem_rebase_carrier_iff K A U V y).2 + (hWV ((mem_rebase_carrier_iff K A U W y).1 hy)) + +/-- A rational cover of `U`, regarded as a cover of the whole spectrum of `U.Sections`. -/ +noncomputable abbrev Cover.rebase + {U : AffinoidRationalSubdomain K A} (𝒱 : Cover K A U) : + Cover K U.Sections (whole K U.Sections) where + m := 𝒱.m + domain i := AffinoidRationalSubdomain.rebase K A U (𝒱.domain i) + subset := fun _ ↦ by + rw [carrier_whole] + exact Set.subset_univ _ + covers := by + rw [carrier_whole] + symm + apply Set.eq_univ_of_forall + intro y + have hyU : ambientPoint K A U y ∈ U.carrier := + ambientPoint_mem_carrier K A U y + rw [𝒱.covers] at hyU + obtain ⟨i, hi⟩ := Set.mem_iUnion.mp hyU + exact Set.mem_iUnion.mpr + ⟨i, (mem_rebase_carrier_iff K A U (𝒱.domain i) y).2 hi⟩ + +section Sections + +variable (hA : IsAffinoidAlgebra K A) + +include hA in +/-- The section algebra of a rational subdomain of an affinoid algebra is affinoid. -/ +theorem isAffinoidAlgebra_sections (U : AffinoidRationalSubdomain K A) : + IsAffinoidAlgebra K U.Sections := by + let π : ContinuousAlgHom K + (TateAlgebra K (Fin hA.presentation.n)) A := + { toAlgHom := hA.presentation.toAlgHom + cont := continuous_tateAlgebra_to_affinoid K hA + (topology_eq_affinoidTopology_of_presentation K A + hA.presentation.n hA.presentation.ideal hA.presentation.equiv) + hA.presentation.toAlgHom } + exact isAffinoidAlgebra_rationalLocalization_of_surjective + K A hA.presentation.n π hA.presentation.toAlgHom_surjective + U.n U.g U.f + +/-- The iterated rational localization obtained by rebasing `V` to `U.Sections` maps to the +original section algebra of `V`. -/ +noncomputable def rebaseToSections + {U V : AffinoidRationalSubdomain K A} (hVU : V.carrier ⊆ U.carrier) : + (rebase K A U V).Sections →A[K] V.Sections := + RationalLocalization.lift K U.Sections V.n + (RationalLocalization.baseMap K A U.n U.g U.f V.g) + (fun i ↦ RationalLocalization.baseMap K A U.n U.g U.f (V.f i)) + (restriction K A hA hVU) + (RationalLocalization.coordinate K A V.n V.g V.f) + (RationalLocalization.isPowerBounded_coordinate K A V.n V.g V.f) + (fun i ↦ by + have hrest := restriction_comp_baseMap K A hA hVU + have hg := congrArg (fun φ : ContinuousAlgHom K A V.Sections ↦ φ V.g) hrest + have hf := congrArg (fun φ : ContinuousAlgHom K A V.Sections ↦ φ (V.f i)) hrest + calc + restriction K A hA hVU + (RationalLocalization.baseMap K A U.n U.g U.f V.g) * + RationalLocalization.coordinate K A V.n V.g V.f i = + RationalLocalization.baseMap K A V.n V.g V.f V.g * + RationalLocalization.coordinate K A V.n V.g V.f i := by + rw [show restriction K A hA hVU + (RationalLocalization.baseMap K A U.n U.g U.f V.g) = + RationalLocalization.baseMap K A V.n V.g V.f V.g by + simpa only [ContinuousAlgHom.comp_apply] using hg] + _ = RationalLocalization.baseMap K A V.n V.g V.f (V.f i) := + RationalLocalization.baseMap_denominator_mul_coordinate K A V.n V.g V.f i + _ = restriction K A hA hVU + (RationalLocalization.baseMap K A U.n U.g U.f (V.f i)) := by + simpa only [ContinuousAlgHom.comp_apply] using hf.symm) + +@[simp] +theorem rebaseToSections_comp_baseMap + {U V : AffinoidRationalSubdomain K A} (hVU : V.carrier ⊆ U.carrier) : + (rebaseToSections K A hA hVU).comp + (RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f) = + restriction K A hA hVU := + RationalLocalization.lift_comp_baseMap K U.Sections V.n + (RationalLocalization.baseMap K A U.n U.g U.f V.g) + (fun i ↦ RationalLocalization.baseMap K A U.n U.g U.f (V.f i)) + (restriction K A hA hVU) + (RationalLocalization.coordinate K A V.n V.g V.f) + (RationalLocalization.isPowerBounded_coordinate K A V.n V.g V.f) _ + +/-- Map the original section algebra of `V` to the iterated localization over `U.Sections`. -/ +noncomputable def sectionsToRebase + {U V : AffinoidRationalSubdomain K A} : + V.Sections →A[K] (rebase K A U V).Sections := + let baseU := RationalLocalization.baseMap K A U.n U.g U.f + let baseR := RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + RationalLocalization.lift K A V.n V.g V.f + (baseR.comp baseU) + (RationalLocalization.coordinate K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f) + (RationalLocalization.isPowerBounded_coordinate K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f) + (fun i ↦ by + change + RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + (RationalLocalization.baseMap K A U.n U.g U.f V.g) * + RationalLocalization.coordinate K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f i = + RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + (RationalLocalization.baseMap K A U.n U.g U.f (V.f i)) + exact RationalLocalization.baseMap_denominator_mul_coordinate K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f i) + +@[simp] +theorem sectionsToRebase_comp_baseMap + {U V : AffinoidRationalSubdomain K A} : + (sectionsToRebase K A (U := U) (V := V)).comp + (RationalLocalization.baseMap K A V.n V.g V.f) = + (RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f).comp + (RationalLocalization.baseMap K A U.n U.g U.f) := + RationalLocalization.lift_comp_baseMap K A V.n V.g V.f + ((RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f).comp + (RationalLocalization.baseMap K A U.n U.g U.f)) + (RationalLocalization.coordinate K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f) + (RationalLocalization.isPowerBounded_coordinate K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f) + (fun i ↦ by + change + RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + (RationalLocalization.baseMap K A U.n U.g U.f V.g) * + RationalLocalization.coordinate K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f i = + RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + (RationalLocalization.baseMap K A U.n U.g U.f (V.f i)) + exact RationalLocalization.baseMap_denominator_mul_coordinate K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f i) + +@[simp] +theorem sectionsToRebase_comp_restriction + {U V : AffinoidRationalSubdomain K A} (hVU : V.carrier ⊆ U.carrier) : + (sectionsToRebase K A (U := U) (V := V)).comp + (restriction K A hA hVU) = + RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f := by + let baseU := RationalLocalization.baseMap K A U.n U.g U.f + let baseR := RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + let φ := (sectionsToRebase K A (U := U) (V := V)).comp + (restriction K A hA hVU) + have hbase : φ.comp baseU = baseR.comp baseU := by + dsimp only [φ] + rw [ContinuousAlgHom.comp_assoc, restriction_comp_baseMap, + sectionsToRebase_comp_baseMap] + apply RationalLocalization.hom_ext_of_isUnit K A φ baseR + · have hg := congrArg (fun q : ContinuousAlgHom K A _ ↦ q U.g) hbase + change IsUnit (φ (baseU U.g)) + rw [show φ (baseU U.g) = baseR (baseU U.g) by + simpa only [ContinuousAlgHom.comp_apply] using hg] + exact + (RationalLocalization.isUnit_baseMap_denominator K A + U.n U.g U.f U.isRational).map baseR.toRingHom + · exact hbase + +@[simp] +theorem rebaseToSections_comp_sectionsToRebase + {U V : AffinoidRationalSubdomain K A} (hVU : V.carrier ⊆ U.carrier) : + (rebaseToSections K A hA hVU).comp + (sectionsToRebase K A (U := U) (V := V)) = + ContinuousAlgHom.id K V.Sections := by + let baseU := RationalLocalization.baseMap K A U.n U.g U.f + let baseV := RationalLocalization.baseMap K A V.n V.g V.f + let baseR := RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + let φ := (rebaseToSections K A hA hVU).comp + (sectionsToRebase K A (U := U) (V := V)) + have hbase : φ.comp baseV = (ContinuousAlgHom.id K V.Sections).comp baseV := by + dsimp only [φ] + calc + ((rebaseToSections K A hA hVU).comp + (sectionsToRebase K A (U := U) (V := V))).comp baseV = + (rebaseToSections K A hA hVU).comp + ((sectionsToRebase K A (U := U) (V := V)).comp baseV) := by + rw [ContinuousAlgHom.comp_assoc] + _ = (rebaseToSections K A hA hVU).comp (baseR.comp baseU) := by + rw [sectionsToRebase_comp_baseMap] + _ = ((rebaseToSections K A hA hVU).comp baseR).comp baseU := by + rw [ContinuousAlgHom.comp_assoc] + _ = (restriction K A hA hVU).comp baseU := by + rw [rebaseToSections_comp_baseMap] + _ = baseV := restriction_comp_baseMap K A hA hVU + _ = (ContinuousAlgHom.id K V.Sections).comp baseV := by + rw [ContinuousAlgHom.id_comp] + apply RationalLocalization.hom_ext_of_isUnit K A φ + (ContinuousAlgHom.id K V.Sections) + · have hg := congrArg (fun q : ContinuousAlgHom K A V.Sections ↦ q V.g) hbase + change IsUnit (φ (baseV V.g)) + rw [show φ (baseV V.g) = baseV V.g by + simpa only [ContinuousAlgHom.comp_apply, ContinuousAlgHom.id_apply] using hg] + exact RationalLocalization.isUnit_baseMap_denominator K A + V.n V.g V.f V.isRational + · exact hbase + +@[simp] +theorem sectionsToRebase_comp_rebaseToSections + {U V : AffinoidRationalSubdomain K A} (hVU : V.carrier ⊆ U.carrier) : + (sectionsToRebase K A (U := U) (V := V)).comp + (rebaseToSections K A hA hVU) = + ContinuousAlgHom.id K (rebase K A U V).Sections := by + let baseR := RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + let φ := (sectionsToRebase K A (U := U) (V := V)).comp + (rebaseToSections K A hA hVU) + have hbase : + φ.comp baseR = + (ContinuousAlgHom.id K (rebase K A U V).Sections).comp baseR := by + dsimp only [φ] + calc + ((sectionsToRebase K A (U := U) (V := V)).comp + (rebaseToSections K A hA hVU)).comp baseR = + (sectionsToRebase K A (U := U) (V := V)).comp + ((rebaseToSections K A hA hVU).comp baseR) := by + rw [ContinuousAlgHom.comp_assoc] + _ = (sectionsToRebase K A (U := U) (V := V)).comp + (restriction K A hA hVU) := by + rw [rebaseToSections_comp_baseMap] + _ = baseR := sectionsToRebase_comp_restriction K A hA hVU + _ = (ContinuousAlgHom.id K (rebase K A U V).Sections).comp baseR := by + rw [ContinuousAlgHom.id_comp] + apply RationalLocalization.hom_ext_of_isUnit K U.Sections φ + (ContinuousAlgHom.id K (rebase K A U V).Sections) + · have hg := congrArg + (fun q : ContinuousAlgHom K U.Sections (rebase K A U V).Sections ↦ + q (rebase K A U V).g) hbase + change IsUnit (φ (baseR (rebase K A U V).g)) + rw [show φ (baseR (rebase K A U V).g) = + baseR (rebase K A U V).g by + simpa only [ContinuousAlgHom.comp_apply, ContinuousAlgHom.id_apply] using hg] + exact RationalLocalization.isUnit_baseMap_denominator K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + (rebase K A U V).isRational + · exact hbase + +/-- Rebasing a rational subdomain inside `U` does not change its section module. -/ +noncomputable def rebaseSectionsLinearEquiv + {U V : AffinoidRationalSubdomain K A} (hVU : V.carrier ⊆ U.carrier) : + (rebase K A U V).Sections ≃ₗ[K] V.Sections where + toFun := rebaseToSections K A hA hVU + invFun := sectionsToRebase K A + left_inv x := + congrArg + (fun φ : ContinuousAlgHom K (rebase K A U V).Sections + (rebase K A U V).Sections ↦ φ x) + (sectionsToRebase_comp_rebaseToSections K A hA hVU) + right_inv x := + congrArg + (fun φ : ContinuousAlgHom K V.Sections V.Sections ↦ φ x) + (rebaseToSections_comp_sectionsToRebase K A hA hVU) + map_add' x y := map_add (rebaseToSections K A hA hVU) x y + map_smul' c x := map_smul (rebaseToSections K A hA hVU) c x + +/-- The equivalence between rebased and original sections commutes with restriction. -/ +theorem rebaseToSections_natural + {U V W : AffinoidRationalSubdomain K A} + (hVU : V.carrier ⊆ U.carrier) (hWV : W.carrier ⊆ V.carrier) : + (restriction K A hA hWV).comp (rebaseToSections K A hA hVU) = + (rebaseToSections K A hA (hWV.trans hVU)).comp + (restriction K U.Sections (isAffinoidAlgebra_sections K A hA U) + (rebase_carrier_subset K A U hWV)) := by + let baseV := RationalLocalization.baseMap K U.Sections + (rebase K A U V).n (rebase K A U V).g (rebase K A U V).f + let φ := (restriction K A hA hWV).comp (rebaseToSections K A hA hVU) + let ψ := (rebaseToSections K A hA (hWV.trans hVU)).comp + (restriction K U.Sections (isAffinoidAlgebra_sections K A hA U) + (rebase_carrier_subset K A U hWV)) + have hbase : φ.comp baseV = ψ.comp baseV := by + dsimp only [φ, ψ] + calc + ((restriction K A hA hWV).comp + (rebaseToSections K A hA hVU)).comp baseV = + (restriction K A hA hWV).comp + ((rebaseToSections K A hA hVU).comp baseV) := by + rw [ContinuousAlgHom.comp_assoc] + _ = (restriction K A hA hWV).comp + (restriction K A hA hVU) := by + rw [rebaseToSections_comp_baseMap] + _ = restriction K A hA (hWV.trans hVU) := + restriction_comp K A hA hVU hWV + _ = (rebaseToSections K A hA (hWV.trans hVU)).comp + (RationalLocalization.baseMap K U.Sections + (rebase K A U W).n (rebase K A U W).g + (rebase K A U W).f) := by + rw [rebaseToSections_comp_baseMap] + _ = (rebaseToSections K A hA (hWV.trans hVU)).comp + ((restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (rebase_carrier_subset K A U hWV)).comp baseV) := by + rw [restriction_comp_baseMap] + _ = ((rebaseToSections K A hA (hWV.trans hVU)).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (rebase_carrier_subset K A U hWV))).comp baseV := by + rw [ContinuousAlgHom.comp_assoc] + apply RationalLocalization.hom_ext_of_isUnit K U.Sections φ ψ + · have hg := congrArg + (fun q : ContinuousAlgHom K U.Sections W.Sections ↦ + q (rebase K A U V).g) hbase + change IsUnit (φ (baseV (rebase K A U V).g)) + rw [show φ (baseV (rebase K A U V).g) = + ψ (baseV (rebase K A U V).g) by + simpa only [ContinuousAlgHom.comp_apply] using hg] + change IsUnit + (rebaseToSections K A hA (hWV.trans hVU) + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (rebase_carrier_subset K A U hWV) + (baseV (rebase K A U V).g))) + exact + ((RationalLocalization.isUnit_baseMap_denominator K U.Sections + (rebase K A U V).n (rebase K A U V).g + (rebase K A U V).f (rebase K A U V).isRational).map + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (rebase_carrier_subset K A U hWV)).toRingHom).map + (rebaseToSections K A hA (hWV.trans hVU)).toRingHom + · exact hbase + +/-- Naturality after replacing rebased rational data by any equal-carrier data. This is the +form used for tuple intersections, whose iterated intersection datum need not literally be the +rebase of the corresponding original datum. -/ +theorem rebaseToSections_natural_of_carrier_eq + {U V W : AffinoidRationalSubdomain K A} + (hVU : V.carrier ⊆ U.carrier) (hWV : W.carrier ⊆ V.carrier) + {V' W' : AffinoidRationalSubdomain K U.Sections} + (hV' : V'.carrier = (rebase K A U V).carrier) + (hW' : W'.carrier = (rebase K A U W).carrier) + (hW'V' : W'.carrier ⊆ V'.carrier) : + (restriction K A hA hWV).comp + ((rebaseToSections K A hA hVU).comp + (restriction K U.Sections (isAffinoidAlgebra_sections K A hA U) hV'.ge)) = + ((rebaseToSections K A hA (hWV.trans hVU)).comp + (restriction K U.Sections (isAffinoidAlgebra_sections K A hA U) hW'.ge)).comp + (restriction K U.Sections (isAffinoidAlgebra_sections K A hA U) hW'V') := by + let hrebased := rebase_carrier_subset K A U hWV + calc + (restriction K A hA hWV).comp + ((rebaseToSections K A hA hVU).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hV'.ge)) = + ((restriction K A hA hWV).comp + (rebaseToSections K A hA hVU)).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hV'.ge) := by + rw [ContinuousAlgHom.comp_assoc] + _ = ((rebaseToSections K A hA (hWV.trans hVU)).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hrebased)).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hV'.ge) := by + rw [rebaseToSections_natural K A hA hVU hWV] + _ = (rebaseToSections K A hA (hWV.trans hVU)).comp + ((restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hrebased).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hV'.ge)) := by + rw [ContinuousAlgHom.comp_assoc] + _ = (rebaseToSections K A hA (hWV.trans hVU)).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) + (hW'.ge.trans hW'V')) := by + rw [restriction_comp] + _ = (rebaseToSections K A hA (hWV.trans hVU)).comp + ((restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hW'.ge).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hW'V')) := by + rw [restriction_comp] + _ = ((rebaseToSections K A hA (hWV.trans hVU)).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hW'.ge)).comp + (restriction K U.Sections + (isAffinoidAlgebra_sections K A hA U) hW'V') := by + rw [ContinuousAlgHom.comp_assoc] + +end Sections + +end AffinoidRationalSubdomain + +end Rigid diff --git a/Rigid/AffinoidSpectrum/TateAcyclicity.lean b/Rigid/AffinoidSpectrum/TateAcyclicity.lean new file mode 100644 index 0000000..279849f --- /dev/null +++ b/Rigid/AffinoidSpectrum/TateAcyclicity.lean @@ -0,0 +1,46 @@ +import Rigid.AffinoidSpectrum.DominatingCover + +set_option linter.style.header false + +/-! +# Tate acyclicity for finite rational covers + +An arbitrary rational cover is first rebased to a cover of a whole affinoid +spectrum. The BGR product construction refines it by a universally acyclic +dominating-family cover. Čech refinement comparison then proves exactness of +the original augmented normalized Čech complex. +-/ + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +/-- **Tate acyclicity.** The augmented normalized Čech complex of every +finite rational cover is exact. -/ +theorem tateAcyclicity (hA : IsAffinoidAlgebra K A) + {U : AffinoidRationalSubdomain K A} (𝒰 : Cover K A U) : + (𝒰.normalizedCechComplex K A hA).Acyclic := by + rw [normalizedCechComplex_acyclic_iff_rebase K A hA] + let hU : IsAffinoidAlgebra K U.Sections := + isAffinoidAlgebra_sections K A hA U + let 𝒰' : Cover K U.Sections (whole K U.Sections) := 𝒰.rebase K A + let 𝒱 : Cover K U.Sections (whole K U.Sections) := + productCover K U.Sections 𝒰' + apply + (normalizedCechComplex_acyclic_iff_of_refinement K U.Sections hU + 𝒰' 𝒱 (productCoverRefinement K U.Sections 𝒰') ?_).2 + · exact productCover_normalizedCechComplex_acyclic K U.Sections hU 𝒰' + · intro p σ + exact restrictTo_productCover_normalizedCechComplex_acyclic + K U.Sections hU 𝒰' + ((𝒰'.cechFamily K U.Sections hU).tupleInter p σ) + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/AffinoidSpectrum/UnitGeneratedCover.lean b/Rigid/AffinoidSpectrum/UnitGeneratedCover.lean new file mode 100644 index 0000000..10c6f9c --- /dev/null +++ b/Rigid/AffinoidSpectrum/UnitGeneratedCover.lean @@ -0,0 +1,161 @@ +import Rigid.AffinoidSpectrum.LaurentProduct +import Rigid.Berkovich.Unit + +set_option linter.style.header false + +/-! +# Rational covers generated by units + +BGR 8.2.2, Lemma 4 refines a rational cover generated by units by a Laurent +cover. We use all ordered ratios `qᵢ / qⱼ`; a chart fixes one inequality for +each ratio, hence induces a total preorder on the finite set of generators. +A maximal generator owns the chart. +-/ + +universe u v + +namespace Rigid + +variable (K : Type u) [NontriviallyNormedField K] [CompleteSpace K] [IsUltrametricDist K] +variable (A : Type v) [NormedCommRing A] [NormedAlgebra K A] [CompleteSpace A] + [IsUltrametricDist A] + +namespace AffinoidRationalSubdomain.Cover + +/-- The quotient `qᵢ / qⱼ`, using the specified unit structure on `qⱼ`. -/ +private noncomputable def unitRatio {r : ℕ} (q : Fin r → A) + (hunit : ∀ i, IsUnit (q i)) (i j : Fin r) : A := + q i * ↑((hunit j).unit⁻¹) + +private theorem apply_unitRatio {r : ℕ} (q : Fin r → A) + (hunit : ∀ i, IsUnit (q i)) (i j : Fin r) + (x : BerkovichSpectrumOver K A) : + x (unitRatio A q hunit i j) = x (q i) * (x (q j))⁻¹ := by + rw [unitRatio, BerkovichSpectrumOver.map_mul] + congr 1 + have hmul : x (q j) * x (↑((hunit j).unit⁻¹) : A) = 1 := by + rw [← BerkovichSpectrumOver.map_mul] + have hring : q j * (↑((hunit j).unit⁻¹) : A) = 1 := by + calc + q j * (↑((hunit j).unit⁻¹) : A) = + (↑(hunit j).unit : A) * ↑((hunit j).unit⁻¹) := + congrArg (fun a : A ↦ a * ↑((hunit j).unit⁻¹)) + (hunit j).unit_spec.symm + _ = 1 := (hunit j).mul_val_inv + rw [hring, BerkovichSpectrumOver.map_one] + exact (inv_eq_of_mul_eq_one_right hmul).symm + +private theorem unitRatio_le_one_iff {r : ℕ} (q : Fin r → A) + (hunit : ∀ i, IsUnit (q i)) (i j : Fin r) + (x : BerkovichSpectrumOver K A) : + x (unitRatio A q hunit i j) ≤ 1 ↔ x (q i) ≤ x (q j) := by + rw [apply_unitRatio K A q hunit i j x] + have hne := BerkovichSpectrumOver.apply_ne_zero_of_isUnit K A (hunit j) x + have hpos : 0 < x (q j) := + lt_of_le_of_ne (BerkovichSpectrumOver.nonneg K A x (q j)) hne.symm + rw [mul_inv_le_iff₀ hpos, one_mul] + +private theorem one_le_unitRatio_iff {r : ℕ} (q : Fin r → A) + (hunit : ∀ i, IsUnit (q i)) (i j : Fin r) + (x : BerkovichSpectrumOver K A) : + 1 ≤ x (unitRatio A q hunit i j) ↔ x (q j) ≤ x (q i) := by + rw [apply_unitRatio K A q hunit i j x] + have hne := BerkovichSpectrumOver.apply_ne_zero_of_isUnit K A (hunit j) x + have hpos : 0 < x (q j) := + lt_of_le_of_ne (BerkovichSpectrumOver.nonneg K A x (q j)) hne.symm + rw [le_mul_inv_iff₀ hpos, one_mul] + +/-- Enumerate all ordered ratios of a finite unit family. -/ +private noncomputable def unitRatioList {r : ℕ} (q : Fin r → A) + (hunit : ∀ i, IsUnit (q i)) : List A := + List.ofFn fun k : Fin (r * r) ↦ + let ij : Fin r × Fin r := finProdFinEquiv.symm k + unitRatio A q hunit ij.1 ij.2 + +private theorem unitRatio_mem_unitRatioList {r : ℕ} (q : Fin r → A) + (hunit : ∀ i, IsUnit (q i)) (i j : Fin r) : + unitRatio A q hunit i j ∈ unitRatioList A q hunit := by + rw [unitRatioList, List.mem_ofFn'] + refine ⟨finProdFinEquiv (i, j), ?_⟩ + simp + +/-- The Laurent product generated by all ordered ratios of a unit family. -/ +noncomputable def unitGeneratedLaurentCover {r : ℕ} (q : Fin r → A) + (hunit : ∀ i, IsUnit (q i)) : Cover K A (whole K A) := + laurentProduct K A 1 (unitRatioList A q hunit) + +private theorem unitGeneratedLaurentCover_pair_total {r : ℕ} (q : Fin r → A) + (hunit : ∀ i, IsUnit (q i)) + (k : Fin (unitGeneratedLaurentCover K A q hunit).m) (i j : Fin r) : + (∀ x ∈ ((unitGeneratedLaurentCover K A q hunit).domain k).carrier, + x (q i) ≤ x (q j)) ∨ + (∀ x ∈ ((unitGeneratedLaurentCover K A q hunit).domain k).carrier, + x (q j) ≤ x (q i)) := by + obtain hsign := + laurentProduct_domain_sign_of_mem K A 1 + (unitRatioList A q hunit) (unitRatio A q hunit i j) + (Or.inr (unitRatio_mem_unitRatioList A q hunit i j)) k + exact hsign.imp + (fun h x hx ↦ (unitRatio_le_one_iff K A q hunit i j x).1 (h x hx)) + (fun h x hx ↦ (one_le_unitRatio_iff K A q hunit i j x).1 (h x hx)) + +private theorem unitGeneratedLaurentCover_exists_owner {r : ℕ} (q : Fin r → A) + (hr : Nonempty (Fin r)) (hunit : ∀ i, IsUnit (q i)) + (k : Fin (unitGeneratedLaurentCover K A q hunit).m) : + ∃ owner : Fin r, + ∀ j x, x ∈ ((unitGeneratedLaurentCover K A q hunit).domain k).carrier → + x (q j) ≤ x (q owner) := by + let R (i j : Fin r) : Prop := + ∀ x, x ∈ ((unitGeneratedLaurentCover K A q hunit).domain k).carrier → + x (q i) ≤ x (q j) + letI : LE (Fin r) := ⟨R⟩ + letI : IsTrans (Fin r) (· ≤ ·) := + ⟨fun _ _ _ hij hjl x hx ↦ (hij x hx).trans (hjl x hx)⟩ + letI : Nonempty (Fin r) := hr + have htotal (i j : Fin r) : i ≤ j ∨ j ≤ i := by + change R i j ∨ R j i + exact + unitGeneratedLaurentCover_pair_total K A q hunit k i j + letI : Std.Total (fun i j : Fin r ↦ i ≤ j) := ⟨htotal⟩ + obtain ⟨owner, hmax⟩ := + (Set.toFinite (Set.univ : Set (Fin r))).exists_maximal Set.univ_nonempty + refine ⟨owner, fun j ↦ ?_⟩ + change R j owner + rcases htotal owner j with h | h + · exact hmax.2 (Set.mem_univ j) h + · exact h + +/-- BGR 8.2.2, Lemma 4: a Laurent cover refines a rational cover generated +by units. -/ +noncomputable def unitGeneratedLaurentRefinement {r : ℕ} (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (hr : Nonempty (Fin r)) + (hunit : ∀ i, IsUnit (q i)) : + Refinement K A (unitGeneratedLaurentCover K A q hunit) (generated K A q hq) where + index k := Classical.choose + (unitGeneratedLaurentCover_exists_owner K A q hr hunit k) + subset k x hx := + (mem_generatedDomain_carrier K A q hq _ x).2 fun j ↦ + Classical.choose_spec + (unitGeneratedLaurentCover_exists_owner K A q hr hunit k) j x hx + +/-- A rational cover generated by a finite unit family is Čech-acyclic. -/ +theorem unitGenerated_normalizedCechComplex_acyclic + (hA : IsAffinoidAlgebra K A) {r : ℕ} (q : Fin r → A) + (hq : Ideal.span (Set.range q) = ⊤) (hr : Nonempty (Fin r)) + (hunit : ∀ i, IsUnit (q i)) : + ((generated K A q hq).normalizedCechComplex K A hA).Acyclic := by + refine + (normalizedCechComplex_acyclic_iff_of_refinement K A hA + (generated K A q hq) (unitGeneratedLaurentCover K A q hunit) + (unitGeneratedLaurentRefinement K A q hq hr hunit) ?_).2 ?_ + · intro p σ + exact restrictTo_laurentProduct_normalizedCechComplex_acyclic K A hA + ((generated K A q hq).cechFamily K A hA |>.tupleInter p σ) + 1 (unitRatioList A q hunit) + · exact + laurentProduct_normalizedCechComplex_acyclic K A hA + 1 (unitRatioList A q hunit) + +end AffinoidRationalSubdomain.Cover + +end Rigid diff --git a/Rigid/Cech/Coface.lean b/Rigid/Cech/Coface.lean new file mode 100644 index 0000000..6d1f17d --- /dev/null +++ b/Rigid/Cech/Coface.lean @@ -0,0 +1,137 @@ +import Mathlib.Algebra.Homology.ShortComplex.ModuleCat +import Mathlib.AlgebraicTopology.AlternatingFaceMapComplex + +set_option linter.style.header false + +/-! +# Alternating complexes from coface maps + +The Čech complex only uses the coface maps of a cosimplicial object. This file packages that +smaller interface, so a presheaf on rational subdomains does not have to be bundled as a full +functor out of the simplex category merely in order to form its Čech differential. +-/ + +open CategoryTheory +open CategoryTheory.Preadditive + +open scoped BigOperators + +universe u v + +namespace Rigid.Cech + +variable (R : Type u) [Ring R] + +/-- A sequence of modules with coface maps satisfying the cosimplicial coface identity. -/ +structure CofaceModule where + X : ℕ → ModuleCat.{v} R + δ (n : ℕ) (i : Fin (n + 2)) : X n ⟶ X (n + 1) + δ_comp_δ (n : ℕ) (i j : Fin (n + 2)) (hij : i ≤ j) : + δ n i ≫ δ (n + 1) j.succ = δ n j ≫ δ (n + 1) i.castSucc + +namespace CofaceModule + +variable {R} + +/-- The alternating sum of the coface maps. -/ +def differential (C : CofaceModule R) (n : ℕ) : C.X n ⟶ C.X (n + 1) := + ∑ i : Fin (n + 2), (-1 : ℤ) ^ (i : ℕ) • C.δ n i + +/-- The alternating coface differential squares to zero. -/ +theorem differential_comp (C : CofaceModule R) (n : ℕ) : + C.differential n ≫ C.differential (n + 1) = 0 := by + simp only [differential, comp_sum, sum_comp] + rw [Finset.sum_comm, ← Finset.sum_product'] + let P := Fin (n + 2) × Fin (n + 3) + let S : Finset P := {ij : P | (ij.2 : ℕ) ≤ (ij.1 : ℕ)} + rw [Finset.univ_product_univ, ← Finset.sum_add_sum_compl S, ← eq_neg_iff_add_eq_zero, + ← Finset.sum_neg_distrib] + let φ : ∀ ij : P, ij ∈ S → P := fun ij hij => + (Fin.castLT ij.2 (lt_of_le_of_lt (Finset.mem_filter.mp hij).right (Fin.is_lt ij.1)), + ij.1.succ) + apply Finset.sum_bij φ + · intro ij hij + simp_rw [S, φ, Finset.compl_filter, Finset.mem_filter_univ, Fin.val_succ, + Fin.val_castLT] at hij ⊢ + lia + · rintro ⟨i, j⟩ hij ⟨i', j'⟩ hij' h + rw [Prod.mk_inj] + exact ⟨by simpa [φ] using! congr_arg Prod.snd h, + by simpa [φ, Fin.castSucc_castLT] using! + congr_arg Fin.castSucc (congr_arg Prod.fst h)⟩ + · rintro ⟨i', j'⟩ hij' + simp_rw [S, Finset.compl_filter, Finset.mem_filter_univ, not_le] at hij' + refine ⟨(j'.pred <| ?_, Fin.castSucc i'), ?_, ?_⟩ + · rintro rfl + simp only [Fin.val_zero, not_lt_zero] at hij' + · simpa [S] using! Nat.le_sub_one_of_lt hij' + · simp only [φ, Fin.castLT_castSucc, Fin.succ_pred] + · rintro ⟨i, j⟩ hij + dsimp + simp only [Preadditive.zsmul_comp, Preadditive.comp_zsmul, smul_smul, ← neg_smul] + congr 1 + · simp only [φ, Fin.val_succ, Fin.val_castLT] + ring + · have hle : (φ (i, j) hij).1 ≤ i := by + simpa [S, φ] using! hij + simpa only [φ, Fin.castSucc_castLT] using + (C.δ_comp_δ n (φ (i, j) hij).1 i hle).symm + +/-- The ordinary (unaugmented) alternating coface complex. -/ +noncomputable def complex (C : CofaceModule R) : CochainComplex (ModuleCat R) ℕ := + CochainComplex.of C.X C.differential C.differential_comp + +@[simp] +theorem complex_X (C : CofaceModule R) (n : ℕ) : C.complex.X n = C.X n := + rfl + +/-- Coface data together with an augmentation. -/ +structure Augmented (C : CofaceModule R) where + augmentationObject : ModuleCat.{v} R + ε : augmentationObject ⟶ C.X 0 + ε_comp : ε ≫ C.δ 0 0 = ε ≫ C.δ 0 1 + +namespace Augmented + +/-- Terms of the augmented complex, with the augmentation placed in degree zero. -/ +abbrev terms {C : CofaceModule R} (A : C.Augmented) : ℕ → ModuleCat.{v} R + | 0 => A.augmentationObject + | n + 1 => C.X n + +/-- Differential of the augmented complex. -/ +abbrev differential {C : CofaceModule R} (A : C.Augmented) : + ∀ n, A.terms n ⟶ A.terms (n + 1) + | 0 => A.ε + | n + 1 => C.differential n + +theorem differential_comp {C : CofaceModule R} (A : C.Augmented) (n : ℕ) : + A.differential n ≫ A.differential (n + 1) = 0 := by + cases n with + | zero => + rw [differential, differential, CofaceModule.differential, Fin.sum_univ_two, + Fin.val_zero, pow_zero, one_zsmul, Fin.val_one, pow_one, neg_zsmul, one_zsmul] + change A.ε ≫ (C.δ 0 0 + -C.δ 0 1) = 0 + rw [comp_add, comp_neg, A.ε_comp, add_neg_cancel] + | succ n => + exact C.differential_comp n + +/-- The augmented alternating coface complex. -/ +noncomputable abbrev complex {C : CofaceModule R} (A : C.Augmented) : + CochainComplex (ModuleCat R) ℕ := + CochainComplex.of A.terms A.differential A.differential_comp + +@[simp] +theorem complex_X_zero {C : CofaceModule R} (A : C.Augmented) : + A.complex.X 0 = A.augmentationObject := + rfl + +@[simp] +theorem complex_X_succ {C : CofaceModule R} (A : C.Augmented) (n : ℕ) : + A.complex.X (n + 1) = C.X n := + rfl + +end Augmented + +end CofaceModule + +end Rigid.Cech diff --git a/Rigid/Cech/Comparison.lean b/Rigid/Cech/Comparison.lean new file mode 100644 index 0000000..2e4814c --- /dev/null +++ b/Rigid/Cech/Comparison.lean @@ -0,0 +1,266 @@ +import Mathlib.Algebra.Homology.HomologicalComplex +import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex +import Mathlib.Algebra.Homology.ShortComplex.ModuleCat + +set_option linter.style.header false + +/-! +# The double-complex staircase argument + +This file contains the algebraic core of the Čech comparison theorem. We use a first-quadrant +double complex of vector spaces whose horizontal and vertical differentials commute. If every +column is exact and every positive row is exact, then the bottom row is exact. + +The proof is the finite staircase argument of BGR 8.1.4: move a vertical differential leftwards +using exactness of the positive rows, solve the resulting vertical cocycle in the first column, +and then unwind the staircase. +-/ + +open CategoryTheory + +universe u v + +namespace Rigid.Cech + +variable (K : Type u) [Field K] + +/-- A first-quadrant double complex of `K`-vector spaces, with commuting differentials. + +The signs needed for a total complex are deliberately absent: the staircase comparison argument +uses only the two square-zero identities and commutation. -/ +structure DoubleComplexGrid where + X : ℕ → ℕ → ModuleCat.{v} K + horizontal (p q : ℕ) : X p q →ₗ[K] X (p + 1) q + vertical (p q : ℕ) : X p q →ₗ[K] X p (q + 1) + horizontal_horizontal (p q : ℕ) (x : X p q) : + horizontal (p + 1) q (horizontal p q x) = 0 + vertical_vertical (p q : ℕ) (x : X p q) : + vertical p (q + 1) (vertical p q x) = 0 + horizontal_vertical (p q : ℕ) (x : X p q) : + horizontal p (q + 1) (vertical p q x) = + vertical (p + 1) q (horizontal p q x) + +namespace DoubleComplexGrid + +variable {K} (D : DoubleComplexGrid.{u, v} K) + +/-- Elementwise exactness of a horizontal row. -/ +def RowExact (q : ℕ) : Prop := + Function.Injective (D.horizontal 0 q) ∧ + ∀ (p : ℕ) (x : D.X (p + 1) q), + D.horizontal (p + 1) q x = 0 → + ∃ y : D.X p q, D.horizontal p q y = x + +/-- Elementwise exactness of a vertical column. -/ +def ColumnExact (p : ℕ) : Prop := + Function.Injective (D.vertical p 0) ∧ + ∀ (q : ℕ) (x : D.X p (q + 1)), + D.vertical p (q + 1) x = 0 → + ∃ y : D.X p q, D.vertical p q y = x + +/-- A horizontal row, regarded as a cochain complex. -/ +noncomputable def row (q : ℕ) : CochainComplex (ModuleCat K) ℕ := + CochainComplex.of + (fun p ↦ D.X p q) + (fun p ↦ ModuleCat.ofHom (D.horizontal p q)) + (fun p ↦ by + apply ModuleCat.hom_ext + apply LinearMap.ext + exact D.horizontal_horizontal p q) + +/-- A vertical column, regarded as a cochain complex. -/ +noncomputable def column (p : ℕ) : CochainComplex (ModuleCat K) ℕ := + CochainComplex.of + (D.X p) + (fun q ↦ ModuleCat.ofHom (D.vertical p q)) + (fun q ↦ by + apply ModuleCat.hom_ext + apply LinearMap.ext + exact D.vertical_vertical p q) + +/-- Elementwise row exactness is equivalent to acyclicity of the associated row complex. -/ +theorem rowExact_iff_acyclic (q : ℕ) : + D.RowExact q ↔ (D.row q).Acyclic := by + constructor + · rintro ⟨hinj, hexact⟩ n + rcases n with _ | n + · rw [(D.row q).exactAt_iff' 0 0 1 (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + change + ∀ x : D.X 0 q, D.horizontal 0 q x = 0 → + ∃ y : D.X 0 q, 0 = x + intro x hx + exact ⟨0, (hinj (by simpa using hx)).symm⟩ + · rw [(D.row q).exactAt_iff' n (n + 1) ((n + 1) + 1) (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + simp only [HomologicalComplex.sc', HomologicalComplex.shortComplexFunctor', row, + CochainComplex.of_d] + intro x hx + exact hexact n x hx + · intro h + constructor + · intro x y hxy + have hzero : D.horizontal 0 q (x - y) = 0 := by + simpa only [map_sub, sub_eq_zero] using hxy + have h0 := h 0 + rw [(D.row q).exactAt_iff' 0 0 1 (by simp) (by simp)] at h0 + rw [ShortComplex.moduleCat_exact_iff] at h0 + change + ∀ z : D.X 0 q, D.horizontal 0 q z = 0 → + ∃ w : D.X 0 q, 0 = z at h0 + obtain ⟨_, hz⟩ := h0 (x - y) hzero + exact sub_eq_zero.mp hz.symm + · intro p x hx + have hp := h (p + 1) + rw [(D.row q).exactAt_iff' p (p + 1) ((p + 1) + 1) (by simp) (by simp)] at hp + rw [ShortComplex.moduleCat_exact_iff] at hp + simp only [HomologicalComplex.sc', HomologicalComplex.shortComplexFunctor', row, + CochainComplex.of_d] at hp + have hp' : + ∀ z : D.X (p + 1) q, D.horizontal (p + 1) q z = 0 → + ∃ w : D.X p q, D.horizontal p q w = z := by + intro z hz + exact hp z hz + exact hp' x hx + +/-- Elementwise column exactness is equivalent to acyclicity of the associated column complex. -/ +theorem columnExact_iff_acyclic (p : ℕ) : + D.ColumnExact p ↔ (D.column p).Acyclic := by + let T : DoubleComplexGrid K := + { X := fun q _ ↦ D.X p q + horizontal := fun q _ ↦ D.vertical p q + vertical := fun _ _ ↦ 0 + horizontal_horizontal := fun q _ ↦ D.vertical_vertical p q + vertical_vertical := by simp + horizontal_vertical := by simp } + change T.RowExact 0 ↔ (T.row 0).Acyclic + exact T.rowExact_iff_acyclic 0 + +/-- A finite left-moving staircase beginning with a horizontal and vertical cocycle. + +For `z : X (p+1) q`, its head is a horizontal preimage in `X p q`; successive heads are +horizontal preimages of the vertical differentials of their predecessors. -/ +inductive Staircase : ∀ (p q : ℕ), D.X (p + 1) q → Type (max u v) + | base {q : ℕ} {z : D.X 1 q} + (a : D.X 0 q) + (horizontal_a : D.horizontal 0 q a = z) + (vertical_a : D.vertical 0 q a = 0) : + Staircase 0 q z + | step {p q : ℕ} {z : D.X (p + 2) q} + (a : D.X (p + 1) q) + (horizontal_a : D.horizontal (p + 1) q a = z) + (tail : Staircase p (q + 1) (D.vertical (p + 1) q a)) : + Staircase (p + 1) q z + +/-- Exact rows construct a staircase from any simultaneous horizontal and vertical cocycle. -/ +theorem exists_staircase_positive + (hrow : ∀ q, D.RowExact (q + 1)) + (p q : ℕ) (z : D.X (p + 1) (q + 1)) + (hz_horizontal : D.horizontal (p + 1) (q + 1) z = 0) + (hz_vertical : D.vertical (p + 1) (q + 1) z = 0) : + Nonempty (D.Staircase p (q + 1) z) := by + induction p generalizing q with + | zero => + obtain ⟨a, ha⟩ := (hrow q).2 0 z hz_horizontal + have hva_horizontal : + D.horizontal 0 (q + 2) (D.vertical 0 (q + 1) a) = 0 := by + rw [D.horizontal_vertical, ha, hz_vertical] + have hva : D.vertical 0 (q + 1) a = 0 := + (hrow (q + 1)).1 (by simpa only [Nat.add_assoc, Nat.add_comm, + Nat.add_left_comm, map_zero] using hva_horizontal) + exact ⟨.base a ha hva⟩ + | succ p ih => + obtain ⟨a, ha⟩ := (hrow q).2 (p + 1) z hz_horizontal + have hva_horizontal : + D.horizontal (p + 1) (q + 2) + (D.vertical (p + 1) (q + 1) a) = 0 := by + rw [D.horizontal_vertical, ha, hz_vertical] + have hva_vertical : + D.vertical (p + 1) (q + 2) + (D.vertical (p + 1) (q + 1) a) = 0 := + D.vertical_vertical (p + 1) (q + 1) a + obtain ⟨tail⟩ := + ih (q + 1) (D.vertical (p + 1) (q + 1) a) + (by simpa only [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using + hva_horizontal) + (by simpa only [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using + hva_vertical) + exact ⟨.step a ha tail⟩ + +/-- Unwind a staircase one row down using exactness of the columns. -/ +theorem Staircase.unwind + (hcolumn : ∀ p, D.ColumnExact p) + {p q : ℕ} {z : D.X (p + 1) (q + 1)} + (s : D.Staircase p (q + 1) z) : + ∃ w : D.X p q, + D.horizontal p (q + 1) (D.vertical p q w) = z := + match p with + | 0 => by + cases s with + | base a ha hva => + obtain ⟨w, hw⟩ := (hcolumn 0).2 q a hva + exact ⟨w, by rw [hw, ha]⟩ + | p + 1 => by + cases s with + | step a ha tail => + obtain ⟨c, hc⟩ := Staircase.unwind hcolumn tail + have hcycle : + D.vertical (p + 1) (q + 1) + (a - D.horizontal p (q + 1) c) = 0 := by + rw [map_sub, ← D.horizontal_vertical, hc, sub_self] + obtain ⟨w, hw⟩ := (hcolumn (p + 1)).2 q _ hcycle + refine ⟨w, ?_⟩ + rw [hw, map_sub, ha, D.horizontal_horizontal, sub_zero] +termination_by p + +/-- **Double-complex staircase lemma.** If all columns and all positive rows of a +first-quadrant double complex of vector spaces are exact, then its bottom row is exact. -/ +theorem rowExact_zero_of_columns_and_positive_rows + (hcolumn : ∀ p, D.ColumnExact p) + (hrow : ∀ q, D.RowExact (q + 1)) : + D.RowExact 0 := by + constructor + · intro x y hxy + have hhorizontal : + D.horizontal 0 0 (x - y) = 0 := by + simpa only [map_sub, sub_eq_zero] using hxy + have hvertical_horizontal : + D.horizontal 0 1 (D.vertical 0 0 (x - y)) = 0 := by + rw [D.horizontal_vertical, hhorizontal, map_zero] + have hvertical : D.vertical 0 0 (x - y) = 0 := + (hrow 0).1 (by simpa using hvertical_horizontal) + have hzero : x - y = 0 := (hcolumn 0).1 (by simpa using hvertical) + exact sub_eq_zero.mp hzero + · intro p x hx + have hz_horizontal : + D.horizontal (p + 1) 1 (D.vertical (p + 1) 0 x) = 0 := by + rw [D.horizontal_vertical, hx, map_zero] + have hz_vertical : + D.vertical (p + 1) 1 (D.vertical (p + 1) 0 x) = 0 := + D.vertical_vertical (p + 1) 0 x + obtain ⟨staircase⟩ := + D.exists_staircase_positive hrow p 0 + (D.vertical (p + 1) 0 x) hz_horizontal hz_vertical + obtain ⟨w, hw⟩ := Staircase.unwind (D := D) hcolumn staircase + have hcycle : + D.vertical (p + 1) 0 (x - D.horizontal p 0 w) = 0 := by + rw [map_sub, ← D.horizontal_vertical, hw, sub_self] + have hzero : x - D.horizontal p 0 w = 0 := + (hcolumn (p + 1)).1 (by simpa using hcycle) + exact ⟨w, (sub_eq_zero.mp hzero).symm⟩ + +/-- Acyclic columns and acyclic positive rows force the bottom row to be acyclic. -/ +theorem row_zero_acyclic_of_columns_and_positive_rows + (hcolumn : ∀ p, (D.column p).Acyclic) + (hrow : ∀ q, (D.row (q + 1)).Acyclic) : + (D.row 0).Acyclic := by + rw [← D.rowExact_iff_acyclic] + apply D.rowExact_zero_of_columns_and_positive_rows + · intro p + exact (D.columnExact_iff_acyclic p).2 (hcolumn p) + · intro q + exact (D.rowExact_iff_acyclic (q + 1)).2 (hrow q) + +end DoubleComplexGrid + +end Rigid.Cech diff --git a/Rigid/Cech/Contracting.lean b/Rigid/Cech/Contracting.lean new file mode 100644 index 0000000..9ae44a6 --- /dev/null +++ b/Rigid/Cech/Contracting.lean @@ -0,0 +1,87 @@ +import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex +import Rigid.Cech.Coface + +set_option linter.style.header false + +/-! +# Contracting homotopies for augmented coface complexes + +This file packages the elementary exactness argument used for restricted Čech complexes which +have a distinguished member containing the covered domain. The geometric construction of the +homotopy is kept separate: once the two contracting identities are available, exactness of the +whole augmented alternating complex is formal. +-/ + +open CategoryTheory + +universe u v + +namespace Rigid.Cech + +variable {R : Type u} [Ring R] + +namespace CofaceModule.Augmented + +variable {C : CofaceModule.{u, v} R} (A : C.Augmented) + +/-- A contracting homotopy for an augmented coface complex, written elementwise. + +`h₀` contracts cochain degree zero to the augmentation object, while `h (n + 1)` contracts +cochain degree `n + 1` to degree `n`. The indexing agrees with the degrees of the augmented +complex: `h n` maps its term in degree `n + 1` to its term in degree `n`. -/ +structure ContractingHomotopy where + h₀ : C.X 0 →ₗ[R] A.augmentationObject + h : ∀ n : ℕ, C.X (n + 1) →ₗ[R] C.X n + h₀_augmentation (x : A.augmentationObject) : + h₀ (A.ε.hom x) = x + degree_zero (x : C.X 0) : + A.ε.hom (h₀ x) + h 0 (C.differential 0 |>.hom x) = x + degree_succ (n : ℕ) (x : C.X (n + 1)) : + (C.differential n).hom (h n x) + + h (n + 1) ((C.differential (n + 1)).hom x) = x + +namespace ContractingHomotopy + +/-- An augmented coface complex admitting a contracting homotopy is acyclic. -/ +theorem acyclic (H : A.ContractingHomotopy) : A.complex.Acyclic := by + intro n + rcases n with _ | _ | n + · rw [A.complex.exactAt_iff' 0 0 1 (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + change ∀ x : A.augmentationObject, A.ε.hom x = 0 → + ∃ y : A.augmentationObject, 0 = x + intro x hx + refine ⟨0, ?_⟩ + have := H.h₀_augmentation x + rw [hx, map_zero] at this + exact this + · rw [A.complex.exactAt_iff' 0 1 2 (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + change ∀ x : C.X 0, (C.differential 0).hom x = 0 → + ∃ y : A.augmentationObject, A.ε.hom y = x + intro x hx + refine ⟨H.h₀ x, ?_⟩ + have h := H.degree_zero x + rw [hx, map_zero] at h + simpa using h + · rw [A.complex.exactAt_iff' (n + 1) ((n + 1) + 1) + (((n + 1) + 1) + 1) (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + simp only [HomologicalComplex.shortComplexFunctor'_obj_f, + HomologicalComplex.shortComplexFunctor'_obj_g, CochainComplex.of_d] + dsimp only [CofaceModule.Augmented.terms, + CofaceModule.Augmented.differential] + change ∀ x : C.X (n + 1), + (C.differential (n + 1)).hom x = 0 → + ∃ y : C.X n, (C.differential n).hom y = x + intro x hx + refine ⟨H.h n x, ?_⟩ + have h := H.degree_succ n x + rw [hx, map_zero] at h + simpa using h + +end ContractingHomotopy + +end CofaceModule.Augmented + +end Rigid.Cech diff --git a/Rigid/Cech/Double.lean b/Rigid/Cech/Double.lean new file mode 100644 index 0000000..132ca38 --- /dev/null +++ b/Rigid/Cech/Double.lean @@ -0,0 +1,529 @@ +import Rigid.Cech.Normalized + +set_option linter.style.header false + +/-! +# Double normalized Čech cochains + +This file constructs the two commuting systems of coface maps attached to a pair of finite +families. These are the entries and the horizontal/vertical arrows of the double Čech complex +used in the refinement comparison theorem. +-/ + +open CategoryTheory + +universe u v w + +namespace Rigid.Cech + +variable {R : Type u} [Ring R] +variable {P : Presheaf.{u, v, w} R} + +namespace Presheaf.Family + +/-- Bidegree `(p,q)` normalized cochains for two finite families over the same ambient domain. -/ +abbrev DoubleCochains (𝒰 𝒱 : P.Family) (p q : ℕ) := + ∀ (σ : 𝒰.StrictTuple p) (τ : 𝒱.StrictTuple q), + P.sections (P.inter (𝒰.tupleInter p σ) (𝒱.tupleInter q τ)) + +/-- Inclusion of a double intersection after deleting one horizontal index. -/ +theorem doubleInter_subset_horizontalDelete (𝒰 𝒱 : P.Family) {p q : ℕ} + (i : Fin (p + 2)) (σ : 𝒰.StrictTuple (p + 1)) (τ : 𝒱.StrictTuple q) : + P.subset + (P.inter (𝒰.tupleInter (p + 1) σ) (𝒱.tupleInter q τ)) + (P.inter (𝒰.tupleInter p (𝒰.strictDelete i σ)) (𝒱.tupleInter q τ)) := by + apply P.subset_inter + · exact P.subset_trans (P.inter_subset_left _ _) + (𝒰.tupleInter_subset_strictDelete i σ) + · exact P.inter_subset_right _ _ + +/-- Inclusion of a double intersection after deleting one vertical index. -/ +theorem doubleInter_subset_verticalDelete (𝒰 𝒱 : P.Family) {p q : ℕ} + (j : Fin (q + 2)) (σ : 𝒰.StrictTuple p) (τ : 𝒱.StrictTuple (q + 1)) : + P.subset + (P.inter (𝒰.tupleInter p σ) (𝒱.tupleInter (q + 1) τ)) + (P.inter (𝒰.tupleInter p σ) (𝒱.tupleInter q (𝒱.strictDelete j τ))) := by + apply P.subset_inter + · exact P.inter_subset_left _ _ + · exact P.subset_trans (P.inter_subset_right _ _) + (𝒱.tupleInter_subset_strictDelete j τ) + +/-- A horizontal coface in the normalized double Čech object. -/ +def horizontalCoface (𝒰 𝒱 : P.Family) (p q : ℕ) (i : Fin (p + 2)) : + DoubleCochains 𝒰 𝒱 p q →ₗ[R] DoubleCochains 𝒰 𝒱 (p + 1) q where + toFun s σ τ := + P.restriction (doubleInter_subset_horizontalDelete 𝒰 𝒱 i σ τ) + (s (𝒰.strictDelete i σ) τ) + map_add' _ _ := by + ext σ τ + exact map_add _ _ _ + map_smul' _ _ := by + ext σ τ + exact map_smul _ _ _ + +/-- A vertical coface in the normalized double Čech object. -/ +def verticalCoface (𝒰 𝒱 : P.Family) (p q : ℕ) (j : Fin (q + 2)) : + DoubleCochains 𝒰 𝒱 p q →ₗ[R] DoubleCochains 𝒰 𝒱 p (q + 1) where + toFun s σ τ := + P.restriction (doubleInter_subset_verticalDelete 𝒰 𝒱 j σ τ) + (s σ (𝒱.strictDelete j τ)) + map_add' _ _ := by + ext σ τ + exact map_add _ _ _ + map_smul' _ _ := by + ext σ τ + exact map_smul _ _ _ + +/-- Horizontal cofaces satisfy the cosimplicial identity. -/ +theorem horizontalCoface_comp_horizontalCoface (𝒰 𝒱 : P.Family) (p q : ℕ) + (i j : Fin (p + 2)) (hij : i ≤ j) : + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 p q i) ≫ + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 (p + 1) q j.succ) = + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 p q j) ≫ + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 (p + 1) q i.castSucc) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ τ + change + P.restriction _ + (P.restriction _ + (s (𝒰.strictDelete i (𝒰.strictDelete j.succ σ)) τ)) = + P.restriction _ + (P.restriction _ + (s (𝒰.strictDelete j (𝒰.strictDelete i.castSucc σ)) τ)) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + have hθ : + i.succAboveOrderEmb.comp j.succ.succAboveOrderEmb = + j.succAboveOrderEmb.comp i.castSucc.succAboveOrderEmb := by + ext k + have hk := SimplexCategory.congr_toOrderHom_apply + (SimplexCategory.δ_comp_δ hij) k + have hk' := congrArg Fin.val hk + change + (j.succ.succAbove (i.succAbove k)).val = + (i.castSucc.succAbove (j.succAbove k)).val + simpa only [SimplexCategory.δ, SimplexCategory.mkHom, + SimplexCategory.comp_toOrderHom, SimplexCategory.Hom.toOrderHom_mk, + OrderHom.comp_coe, OrderEmbedding.toOrderHom_coe, Function.comp_apply, + Fin.succAboveOrderEmb_apply] using hk' + convert congrArg + (fun θ : Fin (p + 1) ↪o Fin (p + 1 + 1 + 1) ↦ + P.restriction + (P.subset_inter + (P.subset_trans (P.inter_subset_left _ _) + (𝒰.tupleInter_subset_precomp (p := p) (q := p + 1 + 1) σ θ)) + (P.inter_subset_right _ _)) + (s (θ.comp σ) τ)) hθ using 1 <;> + simp only [strictDelete, OrderEmbedding.coe_comp, Function.comp_def] <;> + congr 1 + +/-- Vertical cofaces satisfy the cosimplicial identity. -/ +theorem verticalCoface_comp_verticalCoface (𝒰 𝒱 : P.Family) (p q : ℕ) + (i j : Fin (q + 2)) (hij : i ≤ j) : + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p q i) ≫ + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p (q + 1) j.succ) = + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p q j) ≫ + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p (q + 1) i.castSucc) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ τ + change + P.restriction _ + (P.restriction _ + (s σ (𝒱.strictDelete i (𝒱.strictDelete j.succ τ)))) = + P.restriction _ + (P.restriction _ + (s σ (𝒱.strictDelete j (𝒱.strictDelete i.castSucc τ)))) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + have hθ : + i.succAboveOrderEmb.comp j.succ.succAboveOrderEmb = + j.succAboveOrderEmb.comp i.castSucc.succAboveOrderEmb := by + ext k + have hk := SimplexCategory.congr_toOrderHom_apply + (SimplexCategory.δ_comp_δ hij) k + have hk' := congrArg Fin.val hk + change + (j.succ.succAbove (i.succAbove k)).val = + (i.castSucc.succAbove (j.succAbove k)).val + simpa only [SimplexCategory.δ, SimplexCategory.mkHom, + SimplexCategory.comp_toOrderHom, SimplexCategory.Hom.toOrderHom_mk, + OrderHom.comp_coe, OrderEmbedding.toOrderHom_coe, Function.comp_apply, + Fin.succAboveOrderEmb_apply] using hk' + convert congrArg + (fun θ : Fin (q + 1) ↪o Fin (q + 1 + 1 + 1) ↦ + P.restriction + (P.subset_inter + (P.inter_subset_left _ _) + (P.subset_trans (P.inter_subset_right _ _) + (𝒱.tupleInter_subset_precomp (p := q) (q := q + 1 + 1) τ θ))) + (s σ (θ.comp τ))) hθ using 1 <;> + simp only [strictDelete, OrderEmbedding.coe_comp, Function.comp_def] <;> + congr 1 + +/-- Horizontal and vertical cofaces commute. -/ +theorem horizontalCoface_comp_verticalCoface (𝒰 𝒱 : P.Family) (p q : ℕ) + (i : Fin (p + 2)) (j : Fin (q + 2)) : + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 p q i) ≫ + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 (p + 1) q j) = + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p q j) ≫ + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 p (q + 1) i) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ τ + change + P.restriction _ + (P.restriction _ (s (𝒰.strictDelete i σ) (𝒱.strictDelete j τ))) = + P.restriction _ + (P.restriction _ (s (𝒰.strictDelete i σ) (𝒱.strictDelete j τ))) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + +/-- Augment the horizontal direction by cochains of the vertical family. -/ +def horizontalAugmentation (𝒰 𝒱 : P.Family) (q : ℕ) : + 𝒱.NormalizedCochains q →ₗ[R] DoubleCochains 𝒰 𝒱 0 q where + toFun s σ τ := + P.restriction (P.inter_subset_right + (𝒰.tupleInter 0 σ) (𝒱.tupleInter q τ)) (s τ) + map_add' _ _ := by + ext σ τ + exact map_add _ _ _ + map_smul' _ _ := by + ext σ τ + exact map_smul _ _ _ + +/-- Augment the vertical direction by cochains of the horizontal family. -/ +def verticalAugmentation (𝒰 𝒱 : P.Family) (p : ℕ) : + 𝒰.NormalizedCochains p →ₗ[R] DoubleCochains 𝒰 𝒱 p 0 where + toFun s σ τ := + P.restriction (P.inter_subset_left + (𝒰.tupleInter p σ) (𝒱.tupleInter 0 τ)) (s σ) + map_add' _ _ := by + ext σ τ + exact map_add _ _ _ + map_smul' _ _ := by + ext σ τ + exact map_smul _ _ _ + +/-- Horizontal augmentation commutes with vertical cofaces. -/ +theorem horizontalAugmentation_comp_verticalCoface + (𝒰 𝒱 : P.Family) (q : ℕ) (j : Fin (q + 2)) : + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 q) ≫ + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 0 q j) = + ModuleCat.ofHom (𝒱.normalizedCoface q j) ≫ + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 (q + 1)) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ τ + change + P.restriction _ (P.restriction _ (s (𝒱.strictDelete j τ))) = + P.restriction _ (P.restriction _ (s (𝒱.strictDelete j τ))) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + +/-- Vertical augmentation commutes with horizontal cofaces. -/ +theorem verticalAugmentation_comp_horizontalCoface + (𝒰 𝒱 : P.Family) (p : ℕ) (i : Fin (p + 2)) : + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 p) ≫ + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 p 0 i) = + ModuleCat.ofHom (𝒰.normalizedCoface p i) ≫ + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 (p + 1)) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ τ + change + P.restriction _ (P.restriction _ (s (𝒰.strictDelete i σ))) = + P.restriction _ (P.restriction _ (s (𝒰.strictDelete i σ))) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + +/-- The two degree-zero horizontal cofaces agree after horizontal augmentation. -/ +theorem horizontalAugmentation_comp (𝒰 𝒱 : P.Family) (q : ℕ) : + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 q) ≫ + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 0 q 0) = + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 q) ≫ + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 0 q 1) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ τ + change + P.restriction _ (P.restriction _ (s τ)) = + P.restriction _ (P.restriction _ (s τ)) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + +/-- The two degree-zero vertical cofaces agree after vertical augmentation. -/ +theorem verticalAugmentation_comp (𝒰 𝒱 : P.Family) (p : ℕ) : + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 p) ≫ + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p 0 0) = + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 p) ≫ + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p 0 1) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ τ + change + P.restriction _ (P.restriction _ (s σ)) = + P.restriction _ (P.restriction _ (s σ)) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + +/-- The horizontal coface module in a fixed vertical degree. -/ +noncomputable abbrev horizontalCofaceModule (𝒰 𝒱 : P.Family) (q : ℕ) : + CofaceModule R where + X p := ModuleCat.of R (DoubleCochains 𝒰 𝒱 p q) + δ p i := ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 p q i) + δ_comp_δ := fun p i j hij ↦ + horizontalCoface_comp_horizontalCoface 𝒰 𝒱 p q i j hij + +/-- The vertical coface module in a fixed horizontal degree. -/ +noncomputable abbrev verticalCofaceModule (𝒰 𝒱 : P.Family) (p : ℕ) : + CofaceModule R where + X q := ModuleCat.of R (DoubleCochains 𝒰 𝒱 p q) + δ q j := ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p q j) + δ_comp_δ := fun q i j hij ↦ + verticalCoface_comp_verticalCoface 𝒰 𝒱 p q i j hij + +/-- A horizontal row of the double Čech object, augmented by vertical cochains. -/ +noncomputable abbrev horizontalAugmentedCofaceModule + (𝒰 𝒱 : P.Family) (q : ℕ) : + (horizontalCofaceModule 𝒰 𝒱 q).Augmented where + augmentationObject := ModuleCat.of R (𝒱.NormalizedCochains q) + ε := ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 q) + ε_comp := horizontalAugmentation_comp 𝒰 𝒱 q + +/-- A vertical column of the double Čech object, augmented by horizontal cochains. -/ +noncomputable abbrev verticalAugmentedCofaceModule + (𝒰 𝒱 : P.Family) (p : ℕ) : + (verticalCofaceModule 𝒰 𝒱 p).Augmented where + augmentationObject := ModuleCat.of R (𝒰.NormalizedCochains p) + ε := ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 p) + ε_comp := verticalAugmentation_comp 𝒰 𝒱 p + +/-- Horizontal augmentation commutes with the vertical alternating differential. -/ +theorem horizontalAugmentation_comp_verticalDifferential + (𝒰 𝒱 : P.Family) (q : ℕ) : + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 q) ≫ + (∑ j : Fin (q + 2), (-1 : ℤ) ^ (j : ℕ) • + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 0 q j)) = + (∑ j : Fin (q + 2), (-1 : ℤ) ^ (j : ℕ) • + ModuleCat.ofHom (𝒱.normalizedCoface q j)) ≫ + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 (q + 1)) := by + simp only [Preadditive.comp_sum, Preadditive.sum_comp, + Preadditive.comp_zsmul, Preadditive.zsmul_comp] + apply Finset.sum_congr rfl + intro j _ + congr 1 + exact horizontalAugmentation_comp_verticalCoface 𝒰 𝒱 q j + +/-- Vertical augmentation commutes with the horizontal alternating differential. -/ +theorem verticalAugmentation_comp_horizontalDifferential + (𝒰 𝒱 : P.Family) (p : ℕ) : + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 p) ≫ + (∑ i : Fin (p + 2), (-1 : ℤ) ^ (i : ℕ) • + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 p 0 i)) = + (∑ i : Fin (p + 2), (-1 : ℤ) ^ (i : ℕ) • + ModuleCat.ofHom (𝒰.normalizedCoface p i)) ≫ + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 (p + 1)) := by + simp only [Preadditive.comp_sum, Preadditive.sum_comp, + Preadditive.comp_zsmul, Preadditive.zsmul_comp] + apply Finset.sum_congr rfl + intro i _ + congr 1 + exact verticalAugmentation_comp_horizontalCoface 𝒰 𝒱 p i + +/-- The map from vertical Čech cochains into horizontal degree zero of the double complex. -/ +noncomputable def horizontalAugmentationHom (𝒰 𝒱 : P.Family) : + 𝒱.normalizedCofaceModule.complex ⟶ + (verticalCofaceModule 𝒰 𝒱 0).complex := + CochainComplex.ofHom + (fun q ↦ ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 q)) + (fun q ↦ by + simpa only [CofaceModule.complex, CochainComplex.of_d, + CofaceModule.differential] using + horizontalAugmentation_comp_verticalDifferential 𝒰 𝒱 q) + +/-- The map from horizontal Čech cochains into vertical degree zero of the double complex. -/ +noncomputable def verticalAugmentationHom (𝒰 𝒱 : P.Family) : + 𝒰.normalizedCofaceModule.complex ⟶ + (horizontalCofaceModule 𝒰 𝒱 0).complex := + CochainComplex.ofHom + (fun p ↦ ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 p)) + (fun p ↦ by + simpa only [CofaceModule.complex, CochainComplex.of_d, + CofaceModule.differential] using + verticalAugmentation_comp_horizontalDifferential 𝒰 𝒱 p) + +/-- The horizontal and vertical alternating differentials commute. -/ +theorem horizontalDifferential_comp_verticalDifferential + (𝒰 𝒱 : P.Family) (p q : ℕ) : + (∑ i : Fin (p + 2), (-1 : ℤ) ^ (i : ℕ) • + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 p q i)) ≫ + (∑ j : Fin (q + 2), (-1 : ℤ) ^ (j : ℕ) • + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 (p + 1) q j)) = + (∑ j : Fin (q + 2), (-1 : ℤ) ^ (j : ℕ) • + ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p q j)) ≫ + (∑ i : Fin (p + 2), (-1 : ℤ) ^ (i : ℕ) • + ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 p (q + 1) i)) := by + simp only [Preadditive.comp_sum, Preadditive.sum_comp, + Preadditive.comp_zsmul, Preadditive.zsmul_comp, Finset.smul_sum, smul_smul] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro i _ + apply Finset.sum_congr rfl + intro j _ + rw [mul_comm] + congr 1 + exact horizontalCoface_comp_verticalCoface 𝒰 𝒱 p q i j + +/-- The horizontal differential, regarded as a morphism between the vertical complexes. -/ +noncomputable def horizontalDifferential (𝒰 𝒱 : P.Family) (p : ℕ) : + (verticalCofaceModule 𝒰 𝒱 p).complex ⟶ + (verticalCofaceModule 𝒰 𝒱 (p + 1)).complex := + CochainComplex.ofHom + (fun q ↦ (horizontalCofaceModule 𝒰 𝒱 q).differential p) + (fun q ↦ by + simpa only [CofaceModule.complex, CochainComplex.of_d, + CofaceModule.differential] using + horizontalDifferential_comp_verticalDifferential 𝒰 𝒱 p q) + +/-- The normalized double Čech bicomplex of two finite families. -/ +noncomputable def doubleComplex (𝒰 𝒱 : P.Family) : + CochainComplex (CochainComplex (ModuleCat R) ℕ) ℕ := + CochainComplex.of + (fun p ↦ (verticalCofaceModule 𝒰 𝒱 p).complex) + (horizontalDifferential 𝒰 𝒱) + (fun p ↦ by + apply HomologicalComplex.Hom.ext + apply funext + intro q + change + (horizontalCofaceModule 𝒰 𝒱 q).differential p ≫ + (horizontalCofaceModule 𝒰 𝒱 q).differential (p + 1) = 0 + exact (horizontalCofaceModule 𝒰 𝒱 q).differential_comp p) + +/-- The horizontal augmentation followed by the first horizontal differential is zero. -/ +theorem horizontalAugmentationHom_comp_horizontalDifferential + (𝒰 𝒱 : P.Family) : + horizontalAugmentationHom 𝒰 𝒱 ≫ horizontalDifferential 𝒰 𝒱 0 = 0 := by + apply HomologicalComplex.Hom.ext + apply funext + intro q + change + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 q) ≫ + (horizontalCofaceModule 𝒰 𝒱 q).differential 0 = 0 + rw [CofaceModule.differential, Fin.sum_univ_two] + simp only [Fin.val_zero, pow_zero, one_zsmul, Fin.val_one, pow_one, + neg_zsmul, one_zsmul] + change + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 q) ≫ + (ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 0 q 0) + + -ModuleCat.ofHom (horizontalCoface 𝒰 𝒱 0 q 1)) = 0 + rw [Preadditive.comp_add, Preadditive.comp_neg, + horizontalAugmentation_comp 𝒰 𝒱 q, add_neg_cancel] + +/-- Terms of the double Čech complex augmented in the horizontal direction. -/ +noncomputable def horizontalAugmentedTerms (𝒰 𝒱 : P.Family) : + ℕ → CochainComplex (ModuleCat R) ℕ + | 0 => 𝒱.normalizedCofaceModule.complex + | p + 1 => (verticalCofaceModule 𝒰 𝒱 p).complex + +/-- Differential of the double Čech complex augmented in the horizontal direction. -/ +noncomputable def horizontalAugmentedDifferential (𝒰 𝒱 : P.Family) : + ∀ p, horizontalAugmentedTerms 𝒰 𝒱 p ⟶ + horizontalAugmentedTerms 𝒰 𝒱 (p + 1) + | 0 => horizontalAugmentationHom 𝒰 𝒱 + | p + 1 => horizontalDifferential 𝒰 𝒱 p + +/-- The horizontally augmented normalized double Čech bicomplex. -/ +noncomputable def horizontalAugmentedDoubleComplex (𝒰 𝒱 : P.Family) : + CochainComplex (CochainComplex (ModuleCat R) ℕ) ℕ := + CochainComplex.of + (horizontalAugmentedTerms 𝒰 𝒱) + (horizontalAugmentedDifferential 𝒰 𝒱) + (fun p ↦ by + cases p with + | zero => + exact horizontalAugmentationHom_comp_horizontalDifferential 𝒰 𝒱 + | succ p => + apply HomologicalComplex.Hom.ext + apply funext + intro q + change + (horizontalCofaceModule 𝒰 𝒱 q).differential p ≫ + (horizontalCofaceModule 𝒰 𝒱 q).differential (p + 1) = 0 + exact (horizontalCofaceModule 𝒰 𝒱 q).differential_comp p) + +/-- The vertical differential, regarded as a morphism between horizontal complexes. -/ +noncomputable def verticalDifferential (𝒰 𝒱 : P.Family) (q : ℕ) : + (horizontalCofaceModule 𝒰 𝒱 q).complex ⟶ + (horizontalCofaceModule 𝒰 𝒱 (q + 1)).complex := + CochainComplex.ofHom + (fun p ↦ (verticalCofaceModule 𝒰 𝒱 p).differential q) + (fun p ↦ by + simpa only [CofaceModule.complex, CochainComplex.of_d, + CofaceModule.differential] using + (horizontalDifferential_comp_verticalDifferential 𝒰 𝒱 p q).symm) + +/-- The vertical augmentation followed by the first vertical differential is zero. -/ +theorem verticalAugmentationHom_comp_verticalDifferential + (𝒰 𝒱 : P.Family) : + verticalAugmentationHom 𝒰 𝒱 ≫ verticalDifferential 𝒰 𝒱 0 = 0 := by + apply HomologicalComplex.Hom.ext + apply funext + intro p + change + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 p) ≫ + (verticalCofaceModule 𝒰 𝒱 p).differential 0 = 0 + rw [CofaceModule.differential, Fin.sum_univ_two] + simp only [Fin.val_zero, pow_zero, one_zsmul, Fin.val_one, pow_one, + neg_zsmul, one_zsmul] + change + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 p) ≫ + (ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p 0 0) + + -ModuleCat.ofHom (verticalCoface 𝒰 𝒱 p 0 1)) = 0 + rw [Preadditive.comp_add, Preadditive.comp_neg, + verticalAugmentation_comp 𝒰 𝒱 p, add_neg_cancel] + +/-- Terms of the double Čech complex augmented in the vertical direction. -/ +noncomputable def verticalAugmentedTerms (𝒰 𝒱 : P.Family) : + ℕ → CochainComplex (ModuleCat R) ℕ + | 0 => 𝒰.normalizedCofaceModule.complex + | q + 1 => (horizontalCofaceModule 𝒰 𝒱 q).complex + +/-- Differential of the double Čech complex augmented in the vertical direction. -/ +noncomputable def verticalAugmentedDifferential (𝒰 𝒱 : P.Family) : + ∀ q, verticalAugmentedTerms 𝒰 𝒱 q ⟶ + verticalAugmentedTerms 𝒰 𝒱 (q + 1) + | 0 => verticalAugmentationHom 𝒰 𝒱 + | q + 1 => verticalDifferential 𝒰 𝒱 q + +/-- The vertically augmented normalized double Čech bicomplex. -/ +noncomputable def verticalAugmentedDoubleComplex (𝒰 𝒱 : P.Family) : + CochainComplex (CochainComplex (ModuleCat R) ℕ) ℕ := + CochainComplex.of + (verticalAugmentedTerms 𝒰 𝒱) + (verticalAugmentedDifferential 𝒰 𝒱) + (fun q ↦ by + cases q with + | zero => + exact verticalAugmentationHom_comp_verticalDifferential 𝒰 𝒱 + | succ q => + apply HomologicalComplex.Hom.ext + apply funext + intro p + change + (verticalCofaceModule 𝒰 𝒱 p).differential q ≫ + (verticalCofaceModule 𝒰 𝒱 p).differential (q + 1) = 0 + exact (verticalCofaceModule 𝒰 𝒱 p).differential_comp q) + +end Presheaf.Family + +end Rigid.Cech diff --git a/Rigid/Cech/DoubleComparison.lean b/Rigid/Cech/DoubleComparison.lean new file mode 100644 index 0000000..68e2721 --- /dev/null +++ b/Rigid/Cech/DoubleComparison.lean @@ -0,0 +1,255 @@ +import Rigid.Cech.Comparison +import Rigid.Cech.Double + +set_option linter.style.header false + +/-! +# Čech comparison through the fully augmented double complex + +For two finite families with the same ambient domain, this file adjoins the common ambient +sections to the normalized double Čech complex. The abstract staircase lemma then gives the +usual comparison principle: acyclicity of one cover and of all the restricted rows and columns +implies acyclicity of the other cover. +-/ + +open CategoryTheory + +universe u v w + +namespace Rigid.Cech + +variable {K : Type u} [Field K] +variable {P : Presheaf.{u, v, w} K} + +namespace Presheaf.Family + +/-- The objects of the normalized double Čech complex, augmented in both directions. -/ +noncomputable abbrev fullyAugmentedDoubleX (𝒰 𝒱 : P.Family) : + ℕ → ℕ → ModuleCat K + | p, 0 => 𝒰.normalizedAugmentedCofaceModule.terms p + | p, q + 1 => (horizontalAugmentedCofaceModule 𝒰 𝒱 q).terms p + +/-- Horizontal differential of the fully augmented double Čech complex. -/ +noncomputable abbrev fullyAugmentedHorizontal (𝒰 𝒱 : P.Family) : + ∀ p q, fullyAugmentedDoubleX 𝒰 𝒱 p q →ₗ[K] + fullyAugmentedDoubleX 𝒰 𝒱 (p + 1) q + | p, 0 => (𝒰.normalizedAugmentedCofaceModule.differential p).hom + | p, q + 1 => (horizontalAugmentedCofaceModule 𝒰 𝒱 q).differential p |>.hom + +/-- Vertical differential of the fully augmented double Čech complex. The map at the common +corner is supplied explicitly, since the generic presheaf interface does not identify mutually +contained domain objects. -/ +noncomputable abbrev fullyAugmentedVertical (𝒰 𝒱 : P.Family) + (verticalCorner : + P.sections 𝒰.ambient →ₗ[K] 𝒱.NormalizedCochains 0) : + ∀ p q, fullyAugmentedDoubleX 𝒰 𝒱 p q →ₗ[K] + fullyAugmentedDoubleX 𝒰 𝒱 p (q + 1) + | 0, 0 => verticalCorner + | 0, q + 1 => (𝒱.normalizedCofaceModule.differential q).hom + | p + 1, 0 => verticalAugmentation 𝒰 𝒱 p + | p + 1, q + 1 => (verticalCofaceModule 𝒰 𝒱 p).differential q |>.hom + +/-- The fully augmented normalized double Čech complex as an abstract double-complex grid. -/ +noncomputable abbrev fullyAugmentedDoubleGrid (𝒰 𝒱 : P.Family) + (verticalCorner : + P.sections 𝒰.ambient →ₗ[K] 𝒱.NormalizedCochains 0) + (verticalCorner_comp : + ModuleCat.ofHom verticalCorner ≫ + 𝒱.normalizedCofaceModule.differential 0 = 0) + (corner_comm : + ModuleCat.ofHom 𝒰.normalizedAugmentation ≫ + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 0) = + ModuleCat.ofHom verticalCorner ≫ + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 0)) : + DoubleComplexGrid K where + X := fullyAugmentedDoubleX 𝒰 𝒱 + horizontal := fullyAugmentedHorizontal 𝒰 𝒱 + vertical := fullyAugmentedVertical 𝒰 𝒱 verticalCorner + horizontal_horizontal := by + intro p q x + cases q with + | zero => + cases p with + | zero => + exact congrArg + (fun φ ↦ φ.hom x) + (𝒰.normalizedAugmentedCofaceModule.differential_comp 0) + | succ p => + exact congrArg + (fun φ ↦ φ.hom x) + (𝒰.normalizedCofaceModule.differential_comp p) + | succ q => + cases p with + | zero => + exact congrArg + (fun φ ↦ φ.hom x) + ((horizontalAugmentedCofaceModule 𝒰 𝒱 q).differential_comp 0) + | succ p => + exact congrArg + (fun φ ↦ φ.hom x) + ((horizontalCofaceModule 𝒰 𝒱 q).differential_comp p) + vertical_vertical := by + intro p q x + cases q with + | zero => + cases p with + | zero => + exact congrArg (fun φ ↦ φ.hom x) verticalCorner_comp + | succ p => + exact congrArg + (fun φ ↦ φ.hom x) + ((verticalAugmentedCofaceModule 𝒰 𝒱 p).differential_comp 0) + | succ q => + cases p with + | zero => + exact congrArg + (fun φ ↦ φ.hom x) + (𝒱.normalizedCofaceModule.differential_comp q) + | succ p => + exact congrArg + (fun φ ↦ φ.hom x) + ((verticalCofaceModule 𝒰 𝒱 p).differential_comp q) + horizontal_vertical := by + intro p q x + cases p with + | zero => + cases q with + | zero => + change + (ModuleCat.ofHom verticalCorner ≫ + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 0)).hom x = + (ModuleCat.ofHom 𝒰.normalizedAugmentation ≫ + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 0)).hom x + exact congrArg (fun φ ↦ φ.hom x) corner_comm.symm + | succ q => + change + (𝒱.normalizedCofaceModule.differential q ≫ + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 (q + 1))).hom x = + (ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 q) ≫ + (verticalCofaceModule 𝒰 𝒱 0).differential q).hom x + simpa only [CofaceModule.differential] using + congrArg (fun φ ↦ φ.hom x) + (horizontalAugmentation_comp_verticalDifferential 𝒰 𝒱 q).symm + | succ p => + cases q with + | zero => + change + (ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 p) ≫ + (horizontalCofaceModule 𝒰 𝒱 0).differential p).hom x = + (𝒰.normalizedCofaceModule.differential p ≫ + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 (p + 1))).hom x + simpa only [CofaceModule.differential] using + congrArg (fun φ ↦ φ.hom x) + (verticalAugmentation_comp_horizontalDifferential 𝒰 𝒱 p) + | succ q => + change + ((verticalCofaceModule 𝒰 𝒱 p).differential q ≫ + (horizontalCofaceModule 𝒰 𝒱 (q + 1)).differential p).hom x = + ((horizontalCofaceModule 𝒰 𝒱 q).differential p ≫ + (verticalCofaceModule 𝒰 𝒱 (p + 1)).differential q).hom x + simpa only [CofaceModule.differential] using + congrArg (fun φ ↦ φ.hom x) + (horizontalDifferential_comp_verticalDifferential 𝒰 𝒱 p q).symm + +/-- The bottom row of the fully augmented grid is the normalized Čech complex of `𝒰`. -/ +theorem fullyAugmentedDoubleGrid_row_zero (𝒰 𝒱 : P.Family) + (verticalCorner : + P.sections 𝒰.ambient →ₗ[K] 𝒱.NormalizedCochains 0) + (verticalCorner_comp : + ModuleCat.ofHom verticalCorner ≫ + 𝒱.normalizedCofaceModule.differential 0 = 0) + (corner_comm : + ModuleCat.ofHom 𝒰.normalizedAugmentation ≫ + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 0) = + ModuleCat.ofHom verticalCorner ≫ + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 0)) : + (fullyAugmentedDoubleGrid 𝒰 𝒱 verticalCorner + verticalCorner_comp corner_comm).row 0 = + 𝒰.normalizedCechComplex := by + rfl + +/-- Positive rows are the horizontally augmented double Čech rows. -/ +theorem fullyAugmentedDoubleGrid_row_succ (𝒰 𝒱 : P.Family) + (verticalCorner : + P.sections 𝒰.ambient →ₗ[K] 𝒱.NormalizedCochains 0) + (verticalCorner_comp : + ModuleCat.ofHom verticalCorner ≫ + 𝒱.normalizedCofaceModule.differential 0 = 0) + (corner_comm : + ModuleCat.ofHom 𝒰.normalizedAugmentation ≫ + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 0) = + ModuleCat.ofHom verticalCorner ≫ + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 0)) + (q : ℕ) : + (fullyAugmentedDoubleGrid 𝒰 𝒱 verticalCorner + verticalCorner_comp corner_comm).row (q + 1) = + (horizontalAugmentedCofaceModule 𝒰 𝒱 q).complex := by + rfl + +/-- A positive column is canonically isomorphic to the corresponding vertically augmented +double Čech column. The component isomorphisms are identities; the explicit isomorphism only +accounts for the two different recursive presentations of the same terms. -/ +noncomputable def fullyAugmentedDoubleGridColumnSuccIso (𝒰 𝒱 : P.Family) + (verticalCorner : + P.sections 𝒰.ambient →ₗ[K] 𝒱.NormalizedCochains 0) + (verticalCorner_comp : + ModuleCat.ofHom verticalCorner ≫ + 𝒱.normalizedCofaceModule.differential 0 = 0) + (corner_comm : + ModuleCat.ofHom 𝒰.normalizedAugmentation ≫ + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 0) = + ModuleCat.ofHom verticalCorner ≫ + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 0)) + (p : ℕ) : + (fullyAugmentedDoubleGrid 𝒰 𝒱 verticalCorner + verticalCorner_comp corner_comm).column (p + 1) ≅ + (verticalAugmentedCofaceModule 𝒰 𝒱 p).complex := + HomologicalComplex.Hom.isoOfComponents + (fun n ↦ by + cases n <;> exact Iso.refl _) + (by + intro i j hij + simp only [ComplexShape.up_Rel] at hij + subst j + cases i <;> rfl) + +/-- **Normalized Čech comparison theorem.** If `𝒱` is acyclic and all positive augmented +rows and columns of the double Čech complex are acyclic, then `𝒰` is acyclic. -/ +theorem normalizedCechComplex_acyclic_of_double + (𝒰 𝒱 : P.Family) + (verticalCorner : + P.sections 𝒰.ambient →ₗ[K] 𝒱.NormalizedCochains 0) + (verticalCorner_comp : + ModuleCat.ofHom verticalCorner ≫ + 𝒱.normalizedCofaceModule.differential 0 = 0) + (corner_comm : + ModuleCat.ofHom 𝒰.normalizedAugmentation ≫ + ModuleCat.ofHom (verticalAugmentation 𝒰 𝒱 0) = + ModuleCat.ofHom verticalCorner ≫ + ModuleCat.ofHom (horizontalAugmentation 𝒰 𝒱 0)) + (hfirstColumn : + (fullyAugmentedDoubleGrid 𝒰 𝒱 verticalCorner + verticalCorner_comp corner_comm).column 0 |>.Acyclic) + (hrow : ∀ q, (horizontalAugmentedCofaceModule 𝒰 𝒱 q).complex.Acyclic) + (hcolumn : ∀ p, (verticalAugmentedCofaceModule 𝒰 𝒱 p).complex.Acyclic) : + 𝒰.normalizedCechComplex.Acyclic := by + let D := fullyAugmentedDoubleGrid 𝒰 𝒱 verticalCorner + verticalCorner_comp corner_comm + have hDcolumn : ∀ p, (D.column p).Acyclic := by + rintro (_ | p) + · simpa [D] using hfirstColumn + · intro i + exact (hcolumn p i).of_iso + (fullyAugmentedDoubleGridColumnSuccIso 𝒰 𝒱 verticalCorner + verticalCorner_comp corner_comm p).symm + have hDrow : ∀ q, (D.row (q + 1)).Acyclic := by + intro q + rw [fullyAugmentedDoubleGrid_row_succ] + exact hrow q + have hD := D.row_zero_acyclic_of_columns_and_positive_rows hDcolumn hDrow + rw [fullyAugmentedDoubleGrid_row_zero] at hD + exact hD + +end Presheaf.Family + +end Rigid.Cech diff --git a/Rigid/Cech/DoubleTranspose.lean b/Rigid/Cech/DoubleTranspose.lean new file mode 100644 index 0000000..ff1f491 --- /dev/null +++ b/Rigid/Cech/DoubleTranspose.lean @@ -0,0 +1,170 @@ +import Rigid.Cech.Double + +set_option linter.style.header false + +/-! +# Transposing the normalized double Čech complex + +The vertical augmented complex for `(𝒰,𝒱)` is canonically isomorphic to the horizontal +augmented complex for `(𝒱,𝒰)`. Since the abstract presheaf only supplies a chosen binary +intersection, the isomorphism explicitly restricts between `U ∩ V` and `V ∩ U`. +-/ + +open CategoryTheory + +universe u v w + +namespace Rigid.Cech + +variable {K : Type u} [Field K] +variable {P : Presheaf.{u, v, w} K} + +namespace Presheaf + +/-- The two chosen orders of a binary intersection are mutually contained. -/ +theorem inter_swap_subset (U V : P.Domain) : + P.subset (P.inter V U) (P.inter U V) := + P.subset_inter (P.inter_subset_right V U) (P.inter_subset_left V U) + +/-- Sections on the two chosen orders of a binary intersection are canonically equivalent. -/ +noncomputable def interSectionsSwap (U V : P.Domain) : + P.sections (P.inter U V) ≃ₗ[K] P.sections (P.inter V U) where + toFun := P.restriction (P.inter_swap_subset U V) + invFun := P.restriction (P.inter_swap_subset V U) + left_inv x := by + rw [← LinearMap.comp_apply, P.restriction_comp] + simpa only [LinearMap.id_apply] using congrArg + (fun f : P.sections (P.inter U V) →ₗ[K] P.sections (P.inter U V) ↦ f x) + (P.restriction_id (P.inter U V)) + right_inv x := by + rw [← LinearMap.comp_apply, P.restriction_comp] + simpa only [LinearMap.id_apply] using congrArg + (fun f : P.sections (P.inter V U) →ₗ[K] P.sections (P.inter V U) ↦ f x) + (P.restriction_id (P.inter V U)) + map_add' := map_add _ + map_smul' := map_smul _ + +namespace Family + +/-- Transpose double cochains and swap the two intersection factors. -/ +noncomputable def doubleCochainsSwap (𝒰 𝒱 : P.Family) (p q : ℕ) : + DoubleCochains 𝒰 𝒱 p q ≃ₗ[K] DoubleCochains 𝒱 𝒰 q p where + toFun s τ σ := + P.interSectionsSwap (𝒰.tupleInter p σ) (𝒱.tupleInter q τ) (s σ τ) + invFun s σ τ := + (P.interSectionsSwap (𝒰.tupleInter p σ) (𝒱.tupleInter q τ)).symm (s τ σ) + left_inv s := by + funext σ τ + exact (P.interSectionsSwap + (𝒰.tupleInter p σ) (𝒱.tupleInter q τ)).left_inv (s σ τ) + right_inv s := by + funext τ σ + exact (P.interSectionsSwap + (𝒰.tupleInter p σ) (𝒱.tupleInter q τ)).right_inv (s τ σ) + map_add' x y := by + funext τ σ + exact map_add _ _ _ + map_smul' a x := by + funext τ σ + exact map_smul _ _ _ + +theorem verticalAugmentation_doubleCochainsSwap + (𝒰 𝒱 : P.Family) (p : ℕ) : + (doubleCochainsSwap 𝒰 𝒱 p 0).toLinearMap.comp + (verticalAugmentation 𝒰 𝒱 p) = + horizontalAugmentation 𝒱 𝒰 p := by + apply LinearMap.ext + intro s + funext τ σ + simp only [LinearMap.comp_apply, doubleCochainsSwap, interSectionsSwap, + verticalAugmentation, horizontalAugmentation] + change P.restriction _ (P.restriction _ (s σ)) = + P.restriction _ (s σ) + rw [← LinearMap.comp_apply, P.restriction_comp] + +theorem verticalCoface_doubleCochainsSwap + (𝒰 𝒱 : P.Family) (p q : ℕ) (j : Fin (q + 2)) : + (doubleCochainsSwap 𝒰 𝒱 p (q + 1)).toLinearMap.comp + (verticalCoface 𝒰 𝒱 p q j) = + (horizontalCoface 𝒱 𝒰 q p j).comp + (doubleCochainsSwap 𝒰 𝒱 p q).toLinearMap := by + apply LinearMap.ext + intro s + funext τ σ + simp only [LinearMap.comp_apply, doubleCochainsSwap, interSectionsSwap, + verticalCoface, horizontalCoface] + change P.restriction _ (P.restriction _ + (s σ (𝒱.strictDelete j τ))) = + P.restriction _ (P.restriction _ + (s σ (𝒱.strictDelete j τ))) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + +theorem verticalDifferential_doubleCochainsSwap + (𝒰 𝒱 : P.Family) (p q : ℕ) : + (verticalCofaceModule 𝒰 𝒱 p).differential q ≫ + ModuleCat.ofHom + (doubleCochainsSwap 𝒰 𝒱 p (q + 1)).toLinearMap = + ModuleCat.ofHom (doubleCochainsSwap 𝒰 𝒱 p q).toLinearMap ≫ + (horizontalCofaceModule 𝒱 𝒰 p).differential q := by + simp only [CofaceModule.differential, Preadditive.sum_comp, + Preadditive.zsmul_comp, Preadditive.comp_sum, Preadditive.comp_zsmul] + apply Finset.sum_congr rfl + intro j _ + congr 1 + apply ModuleCat.hom_ext + exact verticalCoface_doubleCochainsSwap 𝒰 𝒱 p q j + +/-- The transposition equivalence as an isomorphism of module objects. -/ +noncomputable def doubleCochainsSwapModuleIso + (𝒰 𝒱 : P.Family) (p q : ℕ) : + (verticalCofaceModule 𝒰 𝒱 p).X q ≅ + (horizontalCofaceModule 𝒱 𝒰 p).X q := + (doubleCochainsSwap 𝒰 𝒱 p q).toModuleIso + +noncomputable abbrev verticalAugmentedCofaceModuleComponentIso + (𝒰 𝒱 : P.Family) (p : ℕ) : + ∀ n, + (verticalAugmentedCofaceModule 𝒰 𝒱 p).complex.X n ≅ + (horizontalAugmentedCofaceModule 𝒱 𝒰 p).complex.X n + | 0 => Iso.refl _ + | q + 1 => doubleCochainsSwapModuleIso 𝒰 𝒱 p q + +/-- Transposition identifies a vertical augmented complex with the corresponding horizontal +augmented complex for the swapped pair. -/ +noncomputable def verticalAugmentedCofaceModuleIso + (𝒰 𝒱 : P.Family) (p : ℕ) : + (verticalAugmentedCofaceModule 𝒰 𝒱 p).complex ≅ + (horizontalAugmentedCofaceModule 𝒱 𝒰 p).complex := + HomologicalComplex.Hom.isoOfComponents + (verticalAugmentedCofaceModuleComponentIso 𝒰 𝒱 p) + (by + intro i j hij + simp only [ComplexShape.up_Rel] at hij + subst j + cases i with + | zero => + apply ModuleCat.hom_ext + dsimp only [verticalAugmentedCofaceModuleComponentIso, + CofaceModule.Augmented.complex, CochainComplex.of_d, + CofaceModule.Augmented.differential] + exact (verticalAugmentation_doubleCochainsSwap 𝒰 𝒱 p).symm + | succ q => + dsimp only [verticalAugmentedCofaceModuleComponentIso, + doubleCochainsSwapModuleIso, CofaceModule.Augmented.complex, + CochainComplex.of_d, CofaceModule.Augmented.differential] + simp only [CochainComplex.of_d, LinearEquiv.toModuleIso_hom] + change + ModuleCat.ofHom + (doubleCochainsSwap 𝒰 𝒱 p q).toLinearMap ≫ + (horizontalCofaceModule 𝒱 𝒰 p).differential q = + (verticalCofaceModule 𝒰 𝒱 p).differential q ≫ + ModuleCat.ofHom + (doubleCochainsSwap 𝒰 𝒱 p (q + 1)).toLinearMap + exact (verticalDifferential_doubleCochainsSwap 𝒰 𝒱 p q).symm) + +end Family + +end Presheaf + +end Rigid.Cech diff --git a/Rigid/Cech/Fiber.lean b/Rigid/Cech/Fiber.lean new file mode 100644 index 0000000..7dc4fa7 --- /dev/null +++ b/Rigid/Cech/Fiber.lean @@ -0,0 +1,271 @@ +import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex +import Rigid.Cech.Double + +set_option linter.style.header false + +/-! +# Fibers of the normalized double Čech complex + +A vertical column is the product, over horizontal tuples, of augmented Čech complexes on the +corresponding fixed intersections. This file makes those fiber complexes explicit and proves +that a product of acyclic fibers is acyclic. +-/ + +open CategoryTheory + +universe u v w + +namespace Rigid.Cech + +variable {K : Type u} [Field K] +variable {P : Presheaf.{u, v, w} K} + +namespace Presheaf.Family + +/-- The one-member family consisting of a fixed domain. -/ +noncomputable abbrev singletonFamily (W : P.Domain) : P.Family where + ambient := W + card := 1 + domain _ := W + subset _ := P.subset_refl W + +/-- The unique normalized zero-tuple in the one-member family. -/ +def singletonStrictTuple (W : P.Domain) : + (singletonFamily (P := P) W).StrictTuple 0 := + OrderEmbedding.id _ + +/-- Vertical cochains with one horizontal tuple fixed. -/ +abbrev VerticalFiberCochains (𝒰 𝒱 : P.Family) {p : ℕ} + (σ : 𝒰.StrictTuple p) (q : ℕ) := + ∀ τ : 𝒱.StrictTuple q, + P.sections (P.inter (𝒰.tupleInter p σ) (𝒱.tupleInter q τ)) + +/-- A vertical coface with the horizontal tuple fixed. -/ +def verticalFiberCoface (𝒰 𝒱 : P.Family) {p : ℕ} + (σ : 𝒰.StrictTuple p) (q : ℕ) (j : Fin (q + 2)) : + VerticalFiberCochains 𝒰 𝒱 σ q →ₗ[K] + VerticalFiberCochains 𝒰 𝒱 σ (q + 1) where + toFun s τ := + P.restriction (doubleInter_subset_verticalDelete 𝒰 𝒱 j σ τ) + (s (𝒱.strictDelete j τ)) + map_add' _ _ := by + funext τ + exact map_add _ _ _ + map_smul' _ _ := by + funext τ + exact map_smul _ _ _ + +theorem verticalFiberCoface_comp (𝒰 𝒱 : P.Family) {p : ℕ} + (σ : 𝒰.StrictTuple p) (q : ℕ) + (i j : Fin (q + 2)) (hij : i ≤ j) : + ModuleCat.ofHom (verticalFiberCoface 𝒰 𝒱 σ q i) ≫ + ModuleCat.ofHom (verticalFiberCoface 𝒰 𝒱 σ (q + 1) j.succ) = + ModuleCat.ofHom (verticalFiberCoface 𝒰 𝒱 σ q j) ≫ + ModuleCat.ofHom (verticalFiberCoface 𝒰 𝒱 σ (q + 1) i.castSucc) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext τ + change + P.restriction _ + (P.restriction _ + (s (𝒱.strictDelete i (𝒱.strictDelete j.succ τ)))) = + P.restriction _ + (P.restriction _ + (s (𝒱.strictDelete j (𝒱.strictDelete i.castSucc τ)))) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + have hθ : + i.succAboveOrderEmb.comp j.succ.succAboveOrderEmb = + j.succAboveOrderEmb.comp i.castSucc.succAboveOrderEmb := by + ext k + have hk := SimplexCategory.congr_toOrderHom_apply + (SimplexCategory.δ_comp_δ hij) k + have hk' := congrArg Fin.val hk + change + (j.succ.succAbove (i.succAbove k)).val = + (i.castSucc.succAbove (j.succAbove k)).val + simpa only [SimplexCategory.δ, SimplexCategory.mkHom, + SimplexCategory.comp_toOrderHom, SimplexCategory.Hom.toOrderHom_mk, + OrderHom.comp_coe, OrderEmbedding.toOrderHom_coe, Function.comp_apply, + Fin.succAboveOrderEmb_apply] using hk' + convert congrArg + (fun θ : Fin (q + 1) ↪o Fin (q + 1 + 1 + 1) ↦ + P.restriction + (P.subset_inter + (P.inter_subset_left _ _) + (P.subset_trans (P.inter_subset_right _ _) + (𝒱.tupleInter_subset_precomp (p := q) (q := q + 1 + 1) τ θ))) + (s (θ.comp τ))) hθ using 1 <;> + simp only [strictDelete, OrderEmbedding.coe_comp, Function.comp_def] <;> + congr 1 + +noncomputable abbrev verticalFiberCofaceModule + (𝒰 𝒱 : P.Family) {p : ℕ} (σ : 𝒰.StrictTuple p) : + CofaceModule K where + X q := ModuleCat.of K (VerticalFiberCochains 𝒰 𝒱 σ q) + δ q j := ModuleCat.ofHom (verticalFiberCoface 𝒰 𝒱 σ q j) + δ_comp_δ := verticalFiberCoface_comp 𝒰 𝒱 σ + +/-- Fiberwise vertical augmentation. -/ +def verticalFiberAugmentation (𝒰 𝒱 : P.Family) {p : ℕ} + (σ : 𝒰.StrictTuple p) : + P.sections (𝒰.tupleInter p σ) →ₗ[K] + VerticalFiberCochains 𝒰 𝒱 σ 0 where + toFun s τ := + P.restriction + (P.inter_subset_left (𝒰.tupleInter p σ) (𝒱.tupleInter 0 τ)) s + map_add' _ _ := by + funext τ + exact map_add _ _ _ + map_smul' _ _ := by + funext τ + exact map_smul _ _ _ + +theorem verticalFiberAugmentation_comp (𝒰 𝒱 : P.Family) {p : ℕ} + (σ : 𝒰.StrictTuple p) : + ModuleCat.ofHom (verticalFiberAugmentation 𝒰 𝒱 σ) ≫ + ModuleCat.ofHom (verticalFiberCoface 𝒰 𝒱 σ 0 0) = + ModuleCat.ofHom (verticalFiberAugmentation 𝒰 𝒱 σ) ≫ + ModuleCat.ofHom (verticalFiberCoface 𝒰 𝒱 σ 0 1) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext τ + change P.restriction _ (P.restriction _ s) = + P.restriction _ (P.restriction _ s) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + +noncomputable abbrev verticalFiberAugmentedCofaceModule + (𝒰 𝒱 : P.Family) {p : ℕ} (σ : 𝒰.StrictTuple p) : + (verticalFiberCofaceModule 𝒰 𝒱 σ).Augmented where + augmentationObject := P.sections (𝒰.tupleInter p σ) + ε := ModuleCat.ofHom (verticalFiberAugmentation 𝒰 𝒱 σ) + ε_comp := verticalFiberAugmentation_comp 𝒰 𝒱 σ + +/-- The normalized coface module obtained by restricting a family to a fixed domain. -/ +noncomputable abbrev fixedDomainCofaceModule + (W : P.Domain) (𝒱 : P.Family) : + CofaceModule K := + verticalFiberCofaceModule + (singletonFamily (P := P) W) 𝒱 (singletonStrictTuple (P := P) W) + +/-- The augmented normalized Čech fiber obtained by restricting a family to a fixed domain. -/ +noncomputable abbrev fixedDomainAugmentedCofaceModule + (W : P.Domain) (𝒱 : P.Family) : + (fixedDomainCofaceModule (P := P) W 𝒱).Augmented := + verticalFiberAugmentedCofaceModule + (singletonFamily (P := P) W) 𝒱 (singletonStrictTuple (P := P) W) + +theorem verticalDifferential_apply_fiber + (𝒰 𝒱 : P.Family) (p q : ℕ) + (x : DoubleCochains 𝒰 𝒱 p q) (σ : 𝒰.StrictTuple p) + (τ : 𝒱.StrictTuple (q + 1)) : + ((verticalCofaceModule 𝒰 𝒱 p).differential q).hom x σ τ = + ((verticalFiberCofaceModule 𝒰 𝒱 σ).differential q).hom + (fun τ ↦ x σ τ) τ := by + rw [CofaceModule.differential, CofaceModule.differential] + simp only [ModuleCat.hom_sum, ModuleCat.hom_zsmul, ModuleCat.hom_ofHom, + LinearMap.sum_apply, Finset.sum_apply] + rfl + +/-- A vertical column is acyclic if every fixed-horizontal-tuple fiber is acyclic. -/ +theorem verticalAugmentedCofaceModule_acyclic_of_fibers + (𝒰 𝒱 : P.Family) (p : ℕ) + (hfiber : ∀ σ : 𝒰.StrictTuple p, + (verticalFiberAugmentedCofaceModule 𝒰 𝒱 σ).complex.Acyclic) : + (verticalAugmentedCofaceModule 𝒰 𝒱 p).complex.Acyclic := by + intro n + rcases n with _ | _ | n + · rw [(verticalAugmentedCofaceModule 𝒰 𝒱 p).complex.exactAt_iff' + 0 0 1 (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + change ∀ x : 𝒰.NormalizedCochains p, + verticalAugmentation 𝒰 𝒱 p x = 0 → + ∃ y : 𝒰.NormalizedCochains p, 0 = x + intro x hx + refine ⟨0, ?_⟩ + funext σ + have hs := hfiber σ 0 + rw [(verticalFiberAugmentedCofaceModule 𝒰 𝒱 σ).complex.exactAt_iff' + 0 0 1 (by simp) (by simp)] at hs + rw [ShortComplex.moduleCat_exact_iff] at hs + change ∀ z : P.sections (𝒰.tupleInter p σ), + verticalFiberAugmentation 𝒰 𝒱 σ z = 0 → + ∃ y : P.sections (𝒰.tupleInter p σ), 0 = z at hs + have hxσ : verticalFiberAugmentation 𝒰 𝒱 σ (x σ) = 0 := by + funext τ + exact congrFun (congrFun hx σ) τ + obtain ⟨_, hzero⟩ := hs (x σ) hxσ + exact hzero + · rw [(verticalAugmentedCofaceModule 𝒰 𝒱 p).complex.exactAt_iff' + 0 1 2 (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + change ∀ x : DoubleCochains 𝒰 𝒱 p 0, + ((verticalCofaceModule 𝒰 𝒱 p).differential 0).hom x = 0 → + ∃ y : 𝒰.NormalizedCochains p, + verticalAugmentation 𝒰 𝒱 p y = x + intro x hx + have hexists : ∀ σ : 𝒰.StrictTuple p, + ∃ y : P.sections (𝒰.tupleInter p σ), + verticalFiberAugmentation 𝒰 𝒱 σ y = fun τ ↦ x σ τ := by + intro σ + have hs := hfiber σ 1 + rw [(verticalFiberAugmentedCofaceModule 𝒰 𝒱 σ).complex.exactAt_iff' + 0 1 2 (by simp) (by simp)] at hs + rw [ShortComplex.moduleCat_exact_iff] at hs + change ∀ z : VerticalFiberCochains 𝒰 𝒱 σ 0, + ((verticalFiberCofaceModule 𝒰 𝒱 σ).differential 0).hom z = 0 → + ∃ y : P.sections (𝒰.tupleInter p σ), + verticalFiberAugmentation 𝒰 𝒱 σ y = z at hs + apply hs (fun τ ↦ x σ τ) + funext τ + rw [← verticalDifferential_apply_fiber 𝒰 𝒱 p 0 x σ τ] + exact congrFun (congrFun hx σ) τ + choose y hy using hexists + exact ⟨y, by funext σ τ; exact congrFun (hy σ) τ⟩ + · rw [(verticalAugmentedCofaceModule 𝒰 𝒱 p).complex.exactAt_iff' + (n + 1) ((n + 1) + 1) (((n + 1) + 1) + 1) (by simp) (by simp)] + rw [ShortComplex.moduleCat_exact_iff] + simp only [HomologicalComplex.shortComplexFunctor'_obj_f, + HomologicalComplex.shortComplexFunctor'_obj_g, CochainComplex.of_d] + dsimp only [CofaceModule.Augmented.terms, + CofaceModule.Augmented.differential] + change ∀ x : DoubleCochains 𝒰 𝒱 p (n + 1), + ((verticalCofaceModule 𝒰 𝒱 p).differential (n + 1)).hom x = 0 → + ∃ y : DoubleCochains 𝒰 𝒱 p n, + ((verticalCofaceModule 𝒰 𝒱 p).differential n).hom y = x + intro x hx + have hexists : ∀ σ : 𝒰.StrictTuple p, + ∃ y : VerticalFiberCochains 𝒰 𝒱 σ n, + ((verticalFiberCofaceModule 𝒰 𝒱 σ).differential n).hom y = + fun τ ↦ x σ τ := by + intro σ + have hs := hfiber σ (n + 2) + rw [(verticalFiberAugmentedCofaceModule 𝒰 𝒱 σ).complex.exactAt_iff' + (n + 1) ((n + 1) + 1) (((n + 1) + 1) + 1) + (by simp) (by simp)] at hs + rw [ShortComplex.moduleCat_exact_iff] at hs + simp only [HomologicalComplex.shortComplexFunctor'_obj_f, + HomologicalComplex.shortComplexFunctor'_obj_g, CochainComplex.of_d] at hs + dsimp only [CofaceModule.Augmented.terms, + CofaceModule.Augmented.differential] at hs + change ∀ z : VerticalFiberCochains 𝒰 𝒱 σ (n + 1), + ((verticalFiberCofaceModule 𝒰 𝒱 σ).differential (n + 1)).hom z = 0 → + ∃ y : VerticalFiberCochains 𝒰 𝒱 σ n, + ((verticalFiberCofaceModule 𝒰 𝒱 σ).differential n).hom y = z at hs + apply hs (fun τ ↦ x σ τ) + funext τ + rw [← verticalDifferential_apply_fiber 𝒰 𝒱 p (n + 1) x σ τ] + exact congrFun (congrFun hx σ) τ + choose y hy using hexists + exact ⟨fun σ τ ↦ y σ τ, by + funext σ τ + rw [verticalDifferential_apply_fiber 𝒰 𝒱 p n + (fun σ τ ↦ y σ τ) σ τ] + exact congrFun (hy σ) τ⟩ + +end Presheaf.Family + +end Rigid.Cech diff --git a/Rigid/Cech/Normalized.lean b/Rigid/Cech/Normalized.lean new file mode 100644 index 0000000..48b42a3 --- /dev/null +++ b/Rigid/Cech/Normalized.lean @@ -0,0 +1,178 @@ +import Rigid.Cech.Presheaf + +set_option linter.style.header false + +/-! +# Normalized finite Čech complexes + +For a finite ordered family, the normalized Čech complex is indexed by strictly increasing +tuples. Unlike the unnormalized complex, it is bounded by the cardinality of the family. This is +the form used in the finite double-complex comparison argument and in the reduction of a +two-member Laurent cover to a short exact sequence. +-/ + +open CategoryTheory + +universe u v w + +namespace Rigid.Cech + +variable (R : Type u) [Ring R] +variable {R} +variable {P : Presheaf.{u, v, w} R} + +namespace Presheaf.Family + +/-- A strictly increasing tuple of indices of length `n + 1`. -/ +abbrev StrictTuple (𝒰 : P.Family) (n : ℕ) := + Fin (n + 1) ↪o Fin 𝒰.card + +/-- Degree-`n` normalized Čech cochains. -/ +abbrev NormalizedCochains (𝒰 : P.Family) (n : ℕ) := + ∀ σ : 𝒰.StrictTuple n, P.sections (𝒰.tupleInter n σ) + +/-- Delete one entry from a strictly increasing tuple. -/ +def strictDelete (𝒰 : P.Family) {n : ℕ} (i : Fin (n + 2)) + (σ : 𝒰.StrictTuple (n + 1)) : 𝒰.StrictTuple n := + i.succAboveOrderEmb.comp σ + +/-- The full tuple intersection is contained in the intersection after deleting an entry. -/ +theorem tupleInter_subset_strictDelete (𝒰 : P.Family) {n : ℕ} (i : Fin (n + 2)) + (σ : 𝒰.StrictTuple (n + 1)) : + P.subset (𝒰.tupleInter (n + 1) σ) + (𝒰.tupleInter n (𝒰.strictDelete i σ)) := by + simpa only [strictDelete, OrderEmbedding.coe_comp, Function.comp_def, + Fin.succAboveOrderEmb_apply] using + 𝒰.tupleInter_subset_precomp σ i.succAbove + +/-- One normalized Čech coface map. -/ +def normalizedCoface (𝒰 : P.Family) (n : ℕ) (i : Fin (n + 2)) : + 𝒰.NormalizedCochains n →ₗ[R] 𝒰.NormalizedCochains (n + 1) where + toFun s σ := + P.restriction (𝒰.tupleInter_subset_strictDelete i σ) + (s (𝒰.strictDelete i σ)) + map_add' _ _ := by + ext σ + exact map_add _ _ _ + map_smul' _ _ := by + ext σ + exact map_smul _ _ _ + +private theorem strictDelete_strictDelete {n : ℕ} (𝒰 : P.Family) + (i j : Fin (n + 2)) (hij : i ≤ j) + (σ : 𝒰.StrictTuple (n + 2)) : + 𝒰.strictDelete i (𝒰.strictDelete j.succ σ) = + 𝒰.strictDelete j (𝒰.strictDelete i.castSucc σ) := by + ext k + simp only [strictDelete, OrderEmbedding.coe_comp, Function.comp_apply, + Fin.succAboveOrderEmb_apply] + exact congrArg Fin.val (congrArg σ (by + simpa only [SimplexCategory.δ, SimplexCategory.mkHom, + SimplexCategory.comp_toOrderHom, SimplexCategory.Hom.toOrderHom_mk, + OrderHom.comp_coe, OrderEmbedding.toOrderHom_coe, Function.comp_apply, + Fin.succAboveOrderEmb_apply] using + SimplexCategory.congr_toOrderHom_apply + (SimplexCategory.δ_comp_δ hij) k)) + +/-- The normalized Čech coface maps satisfy the cosimplicial identity. -/ +theorem normalizedCoface_comp_normalizedCoface (𝒰 : P.Family) (n : ℕ) + (i j : Fin (n + 2)) (hij : i ≤ j) : + ModuleCat.ofHom (𝒰.normalizedCoface n i) ≫ + ModuleCat.ofHom (𝒰.normalizedCoface (n + 1) j.succ) = + ModuleCat.ofHom (𝒰.normalizedCoface n j) ≫ + ModuleCat.ofHom (𝒰.normalizedCoface (n + 1) i.castSucc) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ + change + P.restriction _ + (P.restriction _ (s (𝒰.strictDelete i (𝒰.strictDelete j.succ σ)))) = + P.restriction _ + (P.restriction _ (s (𝒰.strictDelete j (𝒰.strictDelete i.castSucc σ)))) + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + have hθ : + i.succAboveOrderEmb.comp j.succ.succAboveOrderEmb = + j.succAboveOrderEmb.comp i.castSucc.succAboveOrderEmb := by + ext k + have hk := SimplexCategory.congr_toOrderHom_apply + (SimplexCategory.δ_comp_δ hij) k + have hk' := congrArg Fin.val hk + change + (j.succ.succAbove (i.succAbove k)).val = + (i.castSucc.succAbove (j.succAbove k)).val + simpa only [SimplexCategory.δ, SimplexCategory.mkHom, + SimplexCategory.comp_toOrderHom, SimplexCategory.Hom.toOrderHom_mk, + OrderHom.comp_coe, OrderEmbedding.toOrderHom_coe, Function.comp_apply, + Fin.succAboveOrderEmb_apply] using hk' + convert congrArg + (fun θ : Fin (n + 1) ↪o Fin (n + 1 + 1 + 1) ↦ + P.restriction + (𝒰.tupleInter_subset_precomp (p := n) (q := n + 1 + 1) σ θ) + (s (θ.comp σ))) hθ using 1 <;> + simp only [strictDelete, OrderEmbedding.coe_comp, Function.comp_def] <;> + congr 1 + +/-- The coface data underlying the normalized finite Čech complex. -/ +noncomputable abbrev normalizedCofaceModule (𝒰 : P.Family) : CofaceModule R where + X n := ModuleCat.of R (𝒰.NormalizedCochains n) + δ n i := ModuleCat.ofHom (𝒰.normalizedCoface n i) + δ_comp_δ := 𝒰.normalizedCoface_comp_normalizedCoface + +/-- Restriction from the ambient domain to normalized degree-zero Čech cochains. -/ +def normalizedAugmentation (𝒰 : P.Family) : + P.sections 𝒰.ambient →ₗ[R] 𝒰.NormalizedCochains 0 where + toFun s σ := P.restriction (𝒰.subset (σ 0)) s + map_add' _ _ := by + ext σ + exact map_add _ _ _ + map_smul' _ _ := by + ext σ + exact map_smul _ _ _ + +/-- The normalized augmentation followed by the two degree-zero cofaces agrees. -/ +theorem normalizedAugmentation_comp (𝒰 : P.Family) : + ModuleCat.ofHom 𝒰.normalizedAugmentation ≫ + ModuleCat.ofHom (𝒰.normalizedCoface 0 0) = + ModuleCat.ofHom 𝒰.normalizedAugmentation ≫ + ModuleCat.ofHom (𝒰.normalizedCoface 0 1) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ + change + (𝒰.normalizedCoface 0 0) (𝒰.normalizedAugmentation s) σ = + (𝒰.normalizedCoface 0 1) (𝒰.normalizedAugmentation s) σ + simp only [normalizedCoface, normalizedAugmentation, strictDelete, + LinearMap.coe_mk, AddHom.coe_mk, OrderEmbedding.coe_comp, Function.comp_apply] + change + ((P.restriction _).comp (P.restriction _)) s = + ((P.restriction _).comp (P.restriction _)) s + rw [P.restriction_comp, P.restriction_comp] + +/-- The augmented normalized coface data of a finite family. -/ +noncomputable abbrev normalizedAugmentedCofaceModule (𝒰 : P.Family) : + 𝒰.normalizedCofaceModule.Augmented where + augmentationObject := P.sections 𝒰.ambient + ε := ModuleCat.ofHom 𝒰.normalizedAugmentation + ε_comp := 𝒰.normalizedAugmentation_comp + +/-- The augmented normalized Čech complex of a finite family. -/ +noncomputable abbrev normalizedCechComplex (𝒰 : P.Family) : + CochainComplex (ModuleCat R) ℕ := + 𝒰.normalizedAugmentedCofaceModule.complex + +@[simp] +theorem normalizedCechComplex_X_zero (𝒰 : P.Family) : + 𝒰.normalizedCechComplex.X 0 = P.sections 𝒰.ambient := + rfl + +/-- Degree zero of the augmented normalized Čech complex is the module on the ambient domain. -/ +noncomputable def normalizedCechComplexDegreeZeroIso (𝒰 : P.Family) : + 𝒰.normalizedCechComplex.X 0 ≅ P.sections 𝒰.ambient := + Iso.refl _ + +end Presheaf.Family + +end Rigid.Cech diff --git a/Rigid/Cech/Presheaf.lean b/Rigid/Cech/Presheaf.lean new file mode 100644 index 0000000..d95d48e --- /dev/null +++ b/Rigid/Cech/Presheaf.lean @@ -0,0 +1,242 @@ +import Rigid.Cech.Coface + +set_option linter.style.header false + +/-! +# Finite Čech complexes of a presheaf + +This file constructs the augmented Čech complex of a finite family in a category of domains with +finite intersections. We use all ordered tuples (including repetitions); this is the standard +unnormalized Čech complex. The construction is deliberately independent of rigid geometry so the +same refinement and comparison arguments can be reused for restricted covers. +-/ + +open CategoryTheory + +open scoped BigOperators + +universe u v w + +namespace Rigid.Cech + +variable (R : Type u) [Ring R] + +/-- The part of a contravariant module-valued presheaf needed to form finite Čech complexes. + +`subset V U` means that `V` is a subdomain of `U`. Antisymmetry is intentionally not required: +two rational data may cut out the same point set without being equal as bundled data. -/ +structure Presheaf where + Domain : Type v + subset : Domain → Domain → Prop + subset_refl (U : Domain) : subset U U + subset_trans {U V W : Domain} : subset W V → subset V U → subset W U + inter : Domain → Domain → Domain + inter_subset_left (U V : Domain) : subset (inter U V) U + inter_subset_right (U V : Domain) : subset (inter U V) V + subset_inter {U V W : Domain} : subset W U → subset W V → subset W (inter U V) + sections : Domain → ModuleCat.{w} R + restriction {U V : Domain} : subset V U → sections U →ₗ[R] sections V + restriction_id (U : Domain) : + restriction (subset_refl U) = LinearMap.id + restriction_comp {U V W : Domain} (hVU : subset V U) (hWV : subset W V) : + (restriction hWV).comp (restriction hVU) = + restriction (subset_trans hWV hVU) + +namespace Presheaf + +variable {R} + +/-- A finite family of subdomains of an ambient domain. The covering condition is not needed to +form the complex and is therefore kept by the geometric layer. -/ +structure Family (P : Presheaf R) where + ambient : P.Domain + card : ℕ + domain : Fin card → P.Domain + subset : ∀ i, P.subset (domain i) ambient + +variable {P : Presheaf R} + +namespace Family + +/-- The intersection indexed by a nonempty ordered tuple. -/ +def tupleInter (𝒰 : P.Family) : + ∀ n : ℕ, (Fin (n + 1) → Fin 𝒰.card) → P.Domain + | 0, σ => 𝒰.domain (σ 0) + | n + 1, σ => + P.inter + (tupleInter 𝒰 n (fun i ↦ σ i.castSucc)) + (𝒰.domain (σ (Fin.last (n + 1)))) + +/-- A tuple intersection is contained in each domain occurring in the tuple. -/ +theorem tupleInter_subset_domain (𝒰 : P.Family) (n : ℕ) + (σ : Fin (n + 1) → Fin 𝒰.card) (i : Fin (n + 1)) : + P.subset (𝒰.tupleInter n σ) (𝒰.domain (σ i)) := by + induction n with + | zero => + have hi : i = 0 := Fin.eq_zero i + subst i + exact P.subset_refl _ + | succ n ih => + refine Fin.lastCases ?_ (fun j ↦ ?_) i + · exact P.inter_subset_right _ _ + · exact P.subset_trans (P.inter_subset_left _ _) (ih _ j) + +/-- A domain contained in every member of a tuple is contained in their intersection. -/ +theorem subset_tupleInter (𝒰 : P.Family) {W : P.Domain} (n : ℕ) + (σ : Fin (n + 1) → Fin 𝒰.card) + (h : ∀ i, P.subset W (𝒰.domain (σ i))) : + P.subset W (𝒰.tupleInter n σ) := by + induction n with + | zero => + simpa only [tupleInter] using h 0 + | succ n ih => + apply P.subset_inter + · apply ih + intro i + exact h i.castSucc + · exact h (Fin.last (n + 1)) + +/-- Intersecting all entries of a tuple gives a subdomain of the intersection indexed by any +precomposition of that tuple. -/ +theorem tupleInter_subset_precomp (𝒰 : P.Family) {p q : ℕ} + (σ : Fin (q + 1) → Fin 𝒰.card) (θ : Fin (p + 1) → Fin (q + 1)) : + P.subset (𝒰.tupleInter q σ) (𝒰.tupleInter p (σ ∘ θ)) := by + apply 𝒰.subset_tupleInter + intro i + exact 𝒰.tupleInter_subset_domain q σ (θ i) + +/-- Degree-`n` unnormalized Čech cochains. -/ +abbrev Cochains (𝒰 : P.Family) (n : ℕ) := + ∀ σ : Fin (n + 1) → Fin 𝒰.card, P.sections (𝒰.tupleInter n σ) + +/-- Delete one entry from a tuple. -/ +def delete (𝒰 : P.Family) {n : ℕ} (i : Fin (n + 2)) + (σ : Fin (n + 2) → Fin 𝒰.card) : Fin (n + 1) → Fin 𝒰.card := + σ ∘ i.succAbove + +/-- One Čech coface map: delete an index and restrict to the full intersection. -/ +def coface (𝒰 : P.Family) (n : ℕ) (i : Fin (n + 2)) : + 𝒰.Cochains n →ₗ[R] 𝒰.Cochains (n + 1) where + toFun s σ := + P.restriction (𝒰.tupleInter_subset_precomp σ i.succAbove) (s (𝒰.delete i σ)) + map_add' _ _ := by + ext σ + exact map_add _ _ _ + map_smul' _ _ := by + ext σ + exact map_smul _ _ _ + +private theorem delete_delete {n : ℕ} (𝒰 : P.Family) + (i j : Fin (n + 2)) (hij : i ≤ j) + (σ : Fin (n + 3) → Fin 𝒰.card) : + 𝒰.delete i (𝒰.delete j.succ σ) = + 𝒰.delete j (𝒰.delete i.castSucc σ) := by + funext k + change σ (j.succ.succAbove (i.succAbove k)) = + σ (i.castSucc.succAbove (j.succAbove k)) + congr 1 + simpa only [SimplexCategory.δ, SimplexCategory.mkHom, + SimplexCategory.comp_toOrderHom, SimplexCategory.Hom.toOrderHom_mk, + OrderHom.comp_coe, OrderEmbedding.toOrderHom_coe, Function.comp_apply, + Fin.succAboveOrderEmb_apply] using + SimplexCategory.congr_toOrderHom_apply + (SimplexCategory.δ_comp_δ hij) k + +/-- The Čech coface maps satisfy the cosimplicial identity. -/ +theorem coface_comp_coface (𝒰 : P.Family) (n : ℕ) + (i j : Fin (n + 2)) (hij : i ≤ j) : + ModuleCat.ofHom (𝒰.coface n i) ≫ ModuleCat.ofHom (𝒰.coface (n + 1) j.succ) = + ModuleCat.ofHom (𝒰.coface n j) ≫ + ModuleCat.ofHom (𝒰.coface (n + 1) i.castSucc) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ + change + P.restriction _ (P.restriction _ (s (𝒰.delete i (𝒰.delete j.succ σ)))) = + P.restriction _ (P.restriction _ (s (𝒰.delete j (𝒰.delete i.castSucc σ)))) + change + ((P.restriction _).comp (P.restriction _)) (s _) = + ((P.restriction _).comp (P.restriction _)) (s _) + rw [P.restriction_comp, P.restriction_comp] + have hθ : + (fun k ↦ j.succ.succAbove (i.succAbove k)) = + fun k ↦ i.castSucc.succAbove (j.succAbove k) := by + funext k + simpa only [SimplexCategory.δ, SimplexCategory.mkHom, + SimplexCategory.comp_toOrderHom, SimplexCategory.Hom.toOrderHom_mk, + OrderHom.comp_coe, OrderEmbedding.toOrderHom_coe, Function.comp_apply, + Fin.succAboveOrderEmb_apply] using + SimplexCategory.congr_toOrderHom_apply + (SimplexCategory.δ_comp_δ hij) k + convert congrArg + (fun θ : Fin (n + 1) → Fin (n + 1 + 1 + 1) ↦ + P.restriction + (𝒰.tupleInter_subset_precomp (p := n) (q := n + 1 + 1) σ θ) + (s (σ ∘ θ))) hθ using 1 <;> + simp only [delete, Function.comp_def] <;> + congr 1 + +/-- The coface module underlying a finite Čech complex. -/ +noncomputable def cofaceModule (𝒰 : P.Family) : CofaceModule R where + X n := ModuleCat.of R (𝒰.Cochains n) + δ n i := ModuleCat.ofHom (𝒰.coface n i) + δ_comp_δ := 𝒰.coface_comp_coface + +/-- Restriction from the ambient domain to degree-zero Čech cochains. -/ +def augmentation (𝒰 : P.Family) : + P.sections 𝒰.ambient →ₗ[R] 𝒰.Cochains 0 where + toFun s σ := P.restriction (𝒰.subset (σ 0)) s + map_add' _ _ := by + ext σ + exact map_add _ _ _ + map_smul' _ _ := by + ext σ + exact map_smul _ _ _ + +/-- The augmentation followed by the two degree-zero cofaces agrees. -/ +theorem augmentation_comp (𝒰 : P.Family) : + ModuleCat.ofHom 𝒰.augmentation ≫ + ModuleCat.ofHom (𝒰.coface 0 0) = + ModuleCat.ofHom 𝒰.augmentation ≫ + ModuleCat.ofHom (𝒰.coface 0 1) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ + change (𝒰.coface 0 0) (𝒰.augmentation s) σ = + (𝒰.coface 0 1) (𝒰.augmentation s) σ + simp only [coface, augmentation, delete, LinearMap.coe_mk, AddHom.coe_mk, + Function.comp_apply] + change + ((P.restriction _).comp (P.restriction _)) s = + ((P.restriction _).comp (P.restriction _)) s + rw [P.restriction_comp, P.restriction_comp] + +/-- The augmented coface data of a finite family. -/ +noncomputable def augmentedCofaceModule (𝒰 : P.Family) : + 𝒰.cofaceModule.Augmented where + augmentationObject := P.sections 𝒰.ambient + ε := ModuleCat.ofHom 𝒰.augmentation + ε_comp := 𝒰.augmentation_comp + +/-- The augmented unnormalized Čech complex of a finite family. -/ +noncomputable def augmentedCechComplex (𝒰 : P.Family) : + CochainComplex (ModuleCat R) ℕ := + 𝒰.augmentedCofaceModule.complex + +@[simp] +theorem augmentedCechComplex_X_zero (𝒰 : P.Family) : + 𝒰.augmentedCechComplex.X 0 = P.sections 𝒰.ambient := + rfl + +/-- Degree zero of the augmented Čech complex is the module on the ambient domain. -/ +noncomputable def augmentedCechComplexDegreeZeroIso (𝒰 : P.Family) : + 𝒰.augmentedCechComplex.X 0 ≅ P.sections 𝒰.ambient := + Iso.refl _ + +end Family + +end Presheaf + +end Rigid.Cech diff --git a/Rigid/Cech/Refinement.lean b/Rigid/Cech/Refinement.lean new file mode 100644 index 0000000..b148078 --- /dev/null +++ b/Rigid/Cech/Refinement.lean @@ -0,0 +1,106 @@ +import Rigid.Cech.Presheaf + +set_option linter.style.header false + +/-! +# Maps of Čech complexes induced by refinements + +A refinement chooses, for every member of a finer finite family, a containing member of the +coarser family. Contravariance of the presheaf then gives the usual map from coarse Čech +cochains to fine Čech cochains. This is the chain-level map used in the BGR double-complex +comparison argument. +-/ + +open CategoryTheory + +universe u v w + +namespace Rigid.Cech + +variable {R : Type u} [Ring R] +variable {P : Presheaf.{u, v, w} R} + +namespace Presheaf.Family + +/-- A finite family `𝒱` refines `𝒰` if every member of `𝒱` is contained in a chosen member of +`𝒰`. -/ +structure Refinement (𝒱 𝒰 : P.Family) where + index : Fin 𝒱.card → Fin 𝒰.card + subset : ∀ j, P.subset (𝒱.domain j) (𝒰.domain (index j)) + +namespace Refinement + +variable {𝒲 𝒱 𝒰 : P.Family} + +/-- Every finite family refines itself. -/ +def refl (𝒰 : P.Family) : Refinement 𝒰 𝒰 where + index := id + subset _ := P.subset_refl _ + +/-- Refinements compose. -/ +def trans (h𝒲𝒱 : Refinement 𝒲 𝒱) (h𝒱𝒰 : Refinement 𝒱 𝒰) : + Refinement 𝒲 𝒰 where + index := h𝒱𝒰.index ∘ h𝒲𝒱.index + subset j := P.subset_trans (h𝒲𝒱.subset j) (h𝒱𝒰.subset (h𝒲𝒱.index j)) + +/-- An intersection in the finer family is contained in the corresponding intersection in the +coarser family. -/ +theorem tupleInter_subset (r : Refinement 𝒱 𝒰) (n : ℕ) + (σ : Fin (n + 1) → Fin 𝒱.card) : + P.subset (𝒱.tupleInter n σ) (𝒰.tupleInter n (r.index ∘ σ)) := by + apply 𝒰.subset_tupleInter + intro i + exact P.subset_trans (𝒱.tupleInter_subset_domain n σ i) (r.subset (σ i)) + +/-- Degreewise restriction of coarse Čech cochains to a refinement. -/ +def cochainMap (r : Refinement 𝒱 𝒰) (n : ℕ) : + 𝒰.Cochains n →ₗ[R] 𝒱.Cochains n where + toFun s σ := P.restriction (r.tupleInter_subset n σ) (s (r.index ∘ σ)) + map_add' _ _ := by + ext σ + exact map_add _ _ _ + map_smul' _ _ := by + ext σ + exact map_smul _ _ _ + +/-- The refinement maps commute with every Čech coface map. -/ +theorem cochainMap_comp_coface (r : Refinement 𝒱 𝒰) (n : ℕ) + (i : Fin (n + 2)) : + ModuleCat.ofHom (r.cochainMap n) ≫ ModuleCat.ofHom (𝒱.coface n i) = + ModuleCat.ofHom (𝒰.coface n i) ≫ ModuleCat.ofHom (r.cochainMap (n + 1)) := by + apply ModuleCat.hom_ext + apply LinearMap.ext + intro s + funext σ + change + P.restriction _ (P.restriction _ + (s (r.index ∘ (𝒱.delete i σ)))) = + P.restriction _ (P.restriction _ + (s (𝒰.delete i (r.index ∘ σ)))) + change + ((P.restriction _).comp (P.restriction _)) (s _) = + ((P.restriction _).comp (P.restriction _)) (s _) + rw [P.restriction_comp, P.restriction_comp] + simp only [delete, Function.comp_def] + congr 1 + +/-- The map of ordinary Čech complexes induced by a refinement. -/ +noncomputable def complexMap (r : Refinement 𝒱 𝒰) : + 𝒰.cofaceModule.complex ⟶ 𝒱.cofaceModule.complex := + CochainComplex.ofHom + (fun n ↦ ModuleCat.ofHom (r.cochainMap n)) + (fun n ↦ by + simp only [CofaceModule.complex, CochainComplex.of_d, + CofaceModule.differential] + rw [Preadditive.comp_sum, Preadditive.sum_comp] + apply Finset.sum_congr rfl + intro i _ + rw [Preadditive.comp_zsmul, Preadditive.zsmul_comp] + congr 1 + exact r.cochainMap_comp_coface n i) + +end Refinement + +end Presheaf.Family + +end Rigid.Cech diff --git a/Rigid/Cech/RefinementContracting.lean b/Rigid/Cech/RefinementContracting.lean new file mode 100644 index 0000000..ae70ad7 --- /dev/null +++ b/Rigid/Cech/RefinementContracting.lean @@ -0,0 +1,746 @@ +import Mathlib.Data.Fin.Parity +import Mathlib.Algebra.BigOperators.Fin +import Rigid.Cech.Contracting +import Rigid.Cech.Double +import Rigid.Cech.DoubleTranspose +import Rigid.Cech.Refinement +import Rigid.Cech.StrictTuple + +set_option linter.style.header false + +/-! +# Contractible rows in the normalized double Čech complex + +If a fixed domain `W` is contained in one member of a finite family, the normalized Čech +complex of the intersections with `W` is contractible. This file constructs the contraction +in the product form needed for rows of the double Čech complex. The distinguished member may +depend on the vertical tuple. +-/ + +universe u v w + +namespace Rigid.Cech + +variable {K : Type u} [Field K] +variable {P : Presheaf.{u, v, w} K} + +namespace Presheaf.Family + +variable (𝒰 𝒱 : P.Family) (q : ℕ) +variable (owner : 𝒱.StrictTuple q → Fin 𝒰.card) + +private theorem restriction_roundtrip_of_strictTuple_eq {n : ℕ} + (W D : P.Domain) (ρ σ : 𝒰.StrictTuple n) (hρσ : ρ = σ) + (hin : P.subset D (P.inter (𝒰.tupleInter n ρ) W)) + (hout : P.subset (P.inter (𝒰.tupleInter n σ) W) D) + (s : ∀ θ : 𝒰.StrictTuple n, + P.sections (P.inter (𝒰.tupleInter n θ) W)) : + P.restriction hout (P.restriction hin (s ρ)) = s σ := by + subst ρ + rw [← LinearMap.comp_apply, P.restriction_comp] + simpa only [LinearMap.id_apply] using congrArg + (fun f : P.sections (P.inter (𝒰.tupleInter n σ) W) →ₗ[K] + P.sections (P.inter (𝒰.tupleInter n σ) W) ↦ f (s σ)) + (P.restriction_id (P.inter (𝒰.tupleInter n σ) W)) + +private theorem restriction_paths_eq_of_strictTuple_eq {n : ℕ} + (W D₁ D₂ E : P.Domain) (ρ₁ ρ₂ : 𝒰.StrictTuple n) (hρ : ρ₁ = ρ₂) + (hin₁ : P.subset D₁ (P.inter (𝒰.tupleInter n ρ₁) W)) + (hout₁ : P.subset E D₁) + (hin₂ : P.subset D₂ (P.inter (𝒰.tupleInter n ρ₂) W)) + (hout₂ : P.subset E D₂) + (s : ∀ θ : 𝒰.StrictTuple n, + P.sections (P.inter (𝒰.tupleInter n θ) W)) : + P.restriction hout₁ (P.restriction hin₁ (s ρ₁)) = + P.restriction hout₂ (P.restriction hin₂ (s ρ₂)) := by + subst ρ₁ + rw [← LinearMap.comp_apply, P.restriction_comp, + ← LinearMap.comp_apply, P.restriction_comp] + +private theorem neg_one_pow_cross (n : ℕ) (k : Fin (n + 2)) (j : Fin (n + 1)) : + (-1 : ℤ) ^ ((j : ℕ) + (j.predAbove k : ℕ)) = + -(-1 : ℤ) ^ ((k : ℕ) + (k.succAbove j : ℕ)) := by + have hsign := Fin.neg_one_pow_succAbove_add_predAbove (R := ℤ) k j + rw [pow_add, pow_add] at hsign ⊢ + have hleft : + (-1 : ℤ) ^ (k.succAbove j : ℕ) * + (-1 : ℤ) ^ (k.succAbove j : ℕ) = 1 := by + rw [← pow_add, (Even.add_self (k.succAbove j : ℕ)).neg_one_pow] + have hright : + (-1 : ℤ) ^ (j : ℕ) * (-1 : ℤ) ^ (j : ℕ) = 1 := by + rw [← pow_add, (Even.add_self (j : ℕ)).neg_one_pow] + calc + (-1 : ℤ) ^ (j : ℕ) * (-1 : ℤ) ^ (j.predAbove k : ℕ) = + ((-1 : ℤ) ^ (k.succAbove j : ℕ) * + (-1 : ℤ) ^ (k.succAbove j : ℕ)) * + ((-1 : ℤ) ^ (j : ℕ) * (-1 : ℤ) ^ (j.predAbove k : ℕ)) := by + rw [hleft, one_mul] + _ = ((-1 : ℤ) ^ (k.succAbove j : ℕ) * + (-1 : ℤ) ^ (j.predAbove k : ℕ)) * + ((-1 : ℤ) ^ (k.succAbove j : ℕ) * + (-1 : ℤ) ^ (j : ℕ)) := by ring + _ = (-((-1 : ℤ) ^ (k : ℕ) * (-1 : ℤ) ^ (j : ℕ))) * + ((-1 : ℤ) ^ (k.succAbove j : ℕ) * + (-1 : ℤ) ^ (j : ℕ)) := by rw [hsign] + _ = -(((-1 : ℤ) ^ (j : ℕ) * (-1 : ℤ) ^ (j : ℕ)) * + ((-1 : ℤ) ^ (k : ℕ) * + (-1 : ℤ) ^ (k.succAbove j : ℕ))) := by ring + _ = -((-1 : ℤ) ^ (k : ℕ) * + (-1 : ℤ) ^ (k.succAbove j : ℕ)) := by rw [hright, one_mul] + +/-- Inserting the distinguished member does not change an intersection with the vertical +tuple: the old double intersection is contained in the new one. -/ +theorem doubleInter_subset_horizontalInsert {n : ℕ} + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) + (σ : 𝒰.StrictTuple n) (τ : 𝒱.StrictTuple q) + (hi : owner τ ∉ 𝒰.strictSupport σ) : + P.subset + (P.inter (𝒰.tupleInter n σ) (𝒱.tupleInter q τ)) + (P.inter + (𝒰.tupleInter (n + 1) (𝒰.strictInsert σ (owner τ) hi)) + (𝒱.tupleInter q τ)) := by + apply P.subset_inter + · apply 𝒰.subset_tupleInter + intro a + let k := 𝒰.strictInsertPosition σ (owner τ) hi + refine Fin.succAboveCases k ?_ (fun j ↦ ?_) a + · rw [𝒰.strictInsert_apply_position] + exact P.subset_trans (P.inter_subset_right _ _) (howner τ) + · have hinsert := congrFun (𝒰.strictInsert_coe σ (owner τ) hi) + (k.succAbove j) + rw [Fin.insertNth_apply_succAbove] at hinsert + rw [hinsert] + exact P.subset_trans (P.inter_subset_left _ _) + (𝒰.tupleInter_subset_domain n σ j) + · exact P.inter_subset_right _ _ + +/-- The vertical tuple itself is contained in the double intersection with its distinguished +horizontal singleton. -/ +theorem verticalTuple_subset_horizontalSingleton + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) + (τ : 𝒱.StrictTuple q) : + P.subset (𝒱.tupleInter q τ) + (P.inter + (𝒰.tupleInter 0 (𝒰.strictSingleton (owner τ))) + (𝒱.tupleInter q τ)) := by + apply P.subset_inter + · simpa only [tupleInter, strictSingleton_apply] using howner τ + · exact P.subset_refl _ + +/-- Evaluation at the distinguished horizontal singleton contracts degree zero to the +horizontal augmentation object. -/ +noncomputable def horizontalContractZero + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) : + DoubleCochains 𝒰 𝒱 0 q →ₗ[K] 𝒱.NormalizedCochains q where + toFun s τ := + P.restriction (verticalTuple_subset_horizontalSingleton + 𝒰 𝒱 q owner howner τ) (s (𝒰.strictSingleton (owner τ)) τ) + map_add' _ _ := by + funext τ + exact map_add _ _ _ + map_smul' _ _ := by + funext τ + exact map_smul _ _ _ + +/-- Insert the distinguished horizontal member, with the standard alternating sign. -/ +noncomputable def horizontalContract + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) + (n : ℕ) : + DoubleCochains 𝒰 𝒱 (n + 1) q →ₗ[K] DoubleCochains 𝒰 𝒱 n q where + toFun s σ τ := + if hi : owner τ ∈ 𝒰.strictSupport σ then + 0 + else + (-1 : ℤ) ^ (𝒰.strictInsertPosition σ (owner τ) hi : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hi) + (s (𝒰.strictInsert σ (owner τ) hi) τ) + map_add' x y := by + funext σ τ + by_cases hi : owner τ ∈ 𝒰.strictSupport σ + · have hi' := (𝒰.mem_strictSupport_iff σ (owner τ)).1 hi + simp only [mem_strictSupport_iff, hi', ↓reduceDIte, Pi.add_apply, zero_add] + · have hi' := not_congr (𝒰.mem_strictSupport_iff σ (owner τ)) |>.mp hi + simp only [mem_strictSupport_iff, hi', ↓reduceDIte, Pi.add_apply, map_add, smul_add] + map_smul' a x := by + funext σ τ + by_cases hi : owner τ ∈ 𝒰.strictSupport σ + · have hi' := (𝒰.mem_strictSupport_iff σ (owner τ)).1 hi + simp only [mem_strictSupport_iff, hi', ↓reduceDIte, Pi.smul_apply, smul_zero] + · have hi' := not_congr (𝒰.mem_strictSupport_iff σ (owner τ)) |>.mp hi + simp only [mem_strictSupport_iff, hi', ↓reduceDIte, Pi.smul_apply, map_smul, + RingHom.id_apply] + rw [smul_comm] + +@[simp] +theorem horizontalContractZero_horizontalAugmentation + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) + (x : 𝒱.NormalizedCochains q) : + horizontalContractZero 𝒰 𝒱 q owner howner + (horizontalAugmentation 𝒰 𝒱 q x) = x := by + funext τ + change P.restriction _ + (P.restriction (P.inter_subset_right + (𝒰.tupleInter 0 (𝒰.strictSingleton (owner τ))) + (𝒱.tupleInter q τ)) (x τ)) = x τ + rw [← LinearMap.comp_apply, P.restriction_comp] + simpa only [LinearMap.id_apply] using congrArg + (fun f : P.sections (𝒱.tupleInter q τ) →ₗ[K] + P.sections (𝒱.tupleInter q τ) ↦ f (x τ)) + (P.restriction_id (𝒱.tupleInter q τ)) + +/-- If the distinguished index is already present, the `d h` part of the homotopy identity is +the identity and the `h d` part vanishes. -/ +theorem horizontalContracting_degree_succ_of_mem + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) + (n : ℕ) (x : DoubleCochains 𝒰 𝒱 (n + 1) q) + (σ : 𝒰.StrictTuple (n + 1)) (τ : 𝒱.StrictTuple q) + (hmem : owner τ ∈ 𝒰.strictSupport σ) : + ((horizontalCofaceModule 𝒰 𝒱 q).differential n).hom + (horizontalContract 𝒰 𝒱 q owner howner n x) σ τ + + horizontalContract 𝒰 𝒱 q owner howner (n + 1) + (((horizontalCofaceModule 𝒰 𝒱 q).differential (n + 1)).hom x) σ τ = + x σ τ := by + have hrange := (𝒰.mem_strictSupport_iff σ (owner τ)).1 hmem + have hhd : + horizontalContract 𝒰 𝒱 q owner howner (n + 1) + (((horizontalCofaceModule 𝒰 𝒱 q).differential (n + 1)).hom x) σ τ = + 0 := by + change + (if hi : owner τ ∈ 𝒰.strictSupport σ then 0 else + (-1 : ℤ) ^ (𝒰.strictInsertPosition σ (owner τ) hi : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hi) + _) = 0 + exact dif_pos hmem + rw [hhd, add_zero] + obtain ⟨k, hk⟩ := hrange + rw [CofaceModule.differential] + simp only [ModuleCat.hom_sum, ModuleCat.hom_zsmul, ModuleCat.hom_ofHom, + LinearMap.sum_apply, Finset.sum_apply] + change + (∑ j : Fin (n + 2), (-1 : ℤ) ^ (j : ℕ) • + P.restriction (doubleInter_subset_horizontalDelete 𝒰 𝒱 j σ τ) + (horizontalContract 𝒰 𝒱 q owner howner n x + (𝒰.strictDelete j σ) τ)) = x σ τ + rw [Finset.sum_eq_single k] + · change + (-1 : ℤ) ^ (k : ℕ) • + P.restriction _ + (horizontalContract 𝒰 𝒱 q owner howner n x + (𝒰.strictDelete k σ) τ) = + x σ τ + have hnot : + owner τ ∉ 𝒰.strictSupport (𝒰.strictDelete k σ) := by + rw [← hk] + exact 𝒰.not_mem_strictSupport_strictDelete σ k + change + (-1 : ℤ) ^ (k : ℕ) • P.restriction _ + (if hi : owner τ ∈ 𝒰.strictSupport (𝒰.strictDelete k σ) then 0 else + (-1 : ℤ) ^ + (𝒰.strictInsertPosition (𝒰.strictDelete k σ) (owner τ) hi : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert 𝒰 𝒱 q owner howner + (𝒰.strictDelete k σ) τ hi) + (x (𝒰.strictInsert (𝒰.strictDelete k σ) (owner τ) hi) τ)) = + x σ τ + rw [dif_neg hnot] + have hinsert : + 𝒰.strictInsert (𝒰.strictDelete k σ) (owner τ) hnot = σ := by + exact 𝒰.strictInsert_strictDelete_of_eq σ k (owner τ) hnot hk + have hposition : + 𝒰.strictInsertPosition (𝒰.strictDelete k σ) (owner τ) hnot = k := by + exact 𝒰.strictInsertPosition_strictDelete_of_eq σ k (owner τ) hnot hk + rw [hposition, map_zsmul, ← mul_zsmul, ← pow_add, + (Even.add_self (k : ℕ)).neg_one_pow, one_zsmul] + exact restriction_roundtrip_of_strictTuple_eq 𝒰 + (𝒱.tupleInter q τ) + (P.inter (𝒰.tupleInter n (𝒰.strictDelete k σ)) + (𝒱.tupleInter q τ)) + (𝒰.strictInsert (𝒰.strictDelete k σ) (owner τ) hnot) σ hinsert + (doubleInter_subset_horizontalInsert 𝒰 𝒱 q owner howner + (𝒰.strictDelete k σ) τ hnot) + (doubleInter_subset_horizontalDelete 𝒰 𝒱 k σ τ) + (fun θ ↦ x θ τ) + · intro j _ hjk + have hownerDelete : + owner τ ∈ 𝒰.strictSupport (𝒰.strictDelete j σ) := by + rw [𝒰.mem_strictSupport_iff] + rcases Fin.eq_self_or_eq_succAbove j k with h | ⟨l, h⟩ + · exact (hjk h.symm).elim + · exact ⟨l, by + change σ (j.succAbove l) = owner τ + rw [← h] + exact hk⟩ + have hownerDelete' : + owner τ ∈ Set.range (𝒰.strictDelete j σ) := + (𝒰.mem_strictSupport_iff (𝒰.strictDelete j σ) (owner τ)).1 + hownerDelete + change + (-1 : ℤ) ^ (j : ℕ) • + P.restriction _ + (horizontalContract 𝒰 𝒱 q owner howner n x + (𝒰.strictDelete j σ) τ) = 0 + change + (-1 : ℤ) ^ (j : ℕ) • P.restriction _ + (if hi : owner τ ∈ 𝒰.strictSupport (𝒰.strictDelete j σ) then 0 else + (-1 : ℤ) ^ + (𝒰.strictInsertPosition (𝒰.strictDelete j σ) (owner τ) hi : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert 𝒰 𝒱 q owner howner + (𝒰.strictDelete j σ) τ hi) + (x (𝒰.strictInsert (𝒰.strictDelete j σ) (owner τ) hi) τ)) = 0 + rw [dif_pos hownerDelete, map_zero, smul_zero] + · simp + +/-- If the distinguished index is absent, the inserted-face term is the identity and all +remaining terms cancel in pairs. -/ +theorem horizontalContracting_degree_succ_of_not_mem + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) + (n : ℕ) (x : DoubleCochains 𝒰 𝒱 (n + 1) q) + (σ : 𝒰.StrictTuple (n + 1)) (τ : 𝒱.StrictTuple q) + (hnot : owner τ ∉ 𝒰.strictSupport σ) : + ((horizontalCofaceModule 𝒰 𝒱 q).differential n).hom + (horizontalContract 𝒰 𝒱 q owner howner n x) σ τ + + horizontalContract 𝒰 𝒱 q owner howner (n + 1) + (((horizontalCofaceModule 𝒰 𝒱 q).differential (n + 1)).hom x) σ τ = + x σ τ := by + let k := 𝒰.strictInsertPosition σ (owner τ) hnot + let ρ := 𝒰.strictInsert σ (owner τ) hnot + let Aterm : Fin (n + 2) → + P.sections + (P.inter (𝒰.tupleInter (n + 1) σ) (𝒱.tupleInter q τ)) := + fun j ↦ + (-1 : ℤ) ^ (j : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 j σ τ) + (horizontalContract 𝒰 𝒱 q owner howner n x + (𝒰.strictDelete j σ) τ) + let Bterm : Fin (n + 2) → + P.sections + (P.inter (𝒰.tupleInter (n + 1) σ) (𝒱.tupleInter q τ)) := + fun j ↦ + (-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hnot) + ((-1 : ℤ) ^ (k.succAbove j : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete + 𝒰 𝒱 (k.succAbove j) ρ τ) + (x (𝒰.strictDelete (k.succAbove j) ρ) τ)) + have hdelete : 𝒰.strictDelete k ρ = σ := by + exact 𝒰.strictDelete_strictInsert σ (owner τ) hnot + have hidentity : + (-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hnot) + ((-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 k ρ τ) + (x (𝒰.strictDelete k ρ) τ)) = + x σ τ := by + rw [map_zsmul, ← mul_zsmul, ← pow_add, + (Even.add_self (k : ℕ)).neg_one_pow, one_zsmul] + exact restriction_roundtrip_of_strictTuple_eq 𝒰 + (𝒱.tupleInter q τ) + (P.inter (𝒰.tupleInter (n + 2) ρ) (𝒱.tupleInter q τ)) + (𝒰.strictDelete k ρ) σ hdelete + (doubleInter_subset_horizontalDelete 𝒰 𝒱 k ρ τ) + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hnot) + (fun θ ↦ x θ τ) + have hcancel (j : Fin (n + 2)) : Aterm j + Bterm j = 0 := by + have hnotDelete : + owner τ ∉ 𝒰.strictSupport (𝒰.strictDelete j σ) := + 𝒰.not_mem_strictSupport_strictDelete_of_not_mem σ (owner τ) hnot j + have hposition : + 𝒰.strictInsertPosition (𝒰.strictDelete j σ) (owner τ) hnotDelete = + j.predAbove k := by + exact 𝒰.strictInsertPosition_after_strictDelete σ (owner τ) hnot j + have htuple : + 𝒰.strictInsert (𝒰.strictDelete j σ) (owner τ) hnotDelete = + 𝒰.strictDelete (k.succAbove j) ρ := by + exact (𝒰.strictDelete_strictInsert_eq_insert + σ (owner τ) hnot j).symm + have hpath : + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 j σ τ) + (P.restriction + (doubleInter_subset_horizontalInsert 𝒰 𝒱 q owner howner + (𝒰.strictDelete j σ) τ hnotDelete) + (x (𝒰.strictInsert (𝒰.strictDelete j σ) + (owner τ) hnotDelete) τ)) = + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hnot) + (P.restriction + (doubleInter_subset_horizontalDelete + 𝒰 𝒱 (k.succAbove j) ρ τ) + (x (𝒰.strictDelete (k.succAbove j) ρ) τ)) := by + exact restriction_paths_eq_of_strictTuple_eq 𝒰 + (𝒱.tupleInter q τ) + (P.inter (𝒰.tupleInter n (𝒰.strictDelete j σ)) + (𝒱.tupleInter q τ)) + (P.inter (𝒰.tupleInter (n + 2) ρ) + (𝒱.tupleInter q τ)) + (P.inter (𝒰.tupleInter (n + 1) σ) + (𝒱.tupleInter q τ)) + (𝒰.strictInsert (𝒰.strictDelete j σ) (owner τ) hnotDelete) + (𝒰.strictDelete (k.succAbove j) ρ) htuple + (doubleInter_subset_horizontalInsert 𝒰 𝒱 q owner howner + (𝒰.strictDelete j σ) τ hnotDelete) + (doubleInter_subset_horizontalDelete 𝒰 𝒱 j σ τ) + (doubleInter_subset_horizontalDelete + 𝒰 𝒱 (k.succAbove j) ρ τ) + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hnot) + (fun θ ↦ x θ τ) + have hsign := neg_one_pow_cross (n + 1) k j + dsimp only [Aterm, Bterm] + change + (-1 : ℤ) ^ (j : ℕ) • + P.restriction _ + (horizontalContract 𝒰 𝒱 q owner howner n x + (𝒰.strictDelete j σ) τ) + + (-1 : ℤ) ^ (k : ℕ) • + P.restriction _ + ((-1 : ℤ) ^ (k.succAbove j : ℕ) • + P.restriction _ (x (𝒰.strictDelete (k.succAbove j) ρ) τ)) = 0 + change + (-1 : ℤ) ^ (j : ℕ) • + P.restriction _ + (if hi : owner τ ∈ + 𝒰.strictSupport (𝒰.strictDelete j σ) then 0 else + (-1 : ℤ) ^ + (𝒰.strictInsertPosition + (𝒰.strictDelete j σ) (owner τ) hi : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert 𝒰 𝒱 q owner howner + (𝒰.strictDelete j σ) τ hi) + (x (𝒰.strictInsert (𝒰.strictDelete j σ) + (owner τ) hi) τ)) + + (-1 : ℤ) ^ (k : ℕ) • + P.restriction _ + ((-1 : ℤ) ^ (k.succAbove j : ℕ) • + P.restriction _ (x (𝒰.strictDelete (k.succAbove j) ρ) τ)) = 0 + rw [dif_neg hnotDelete, map_zsmul, map_zsmul, + ← mul_zsmul, ← mul_zsmul, ← pow_add, ← pow_add, hposition] + rw [hsign, neg_zsmul, hpath, neg_add_cancel] + have hfirst : + ((horizontalCofaceModule 𝒰 𝒱 q).differential n).hom + (horizontalContract 𝒰 𝒱 q owner howner n x) σ τ = + ∑ j : Fin (n + 2), Aterm j := by + rw [CofaceModule.differential] + simp only [ModuleCat.hom_sum, ModuleCat.hom_zsmul, ModuleCat.hom_ofHom, + LinearMap.sum_apply, Finset.sum_apply] + rfl + have hsecond : + ((horizontalCofaceModule 𝒰 𝒱 q).differential (n + 1)).hom x ρ τ = + ∑ l : Fin (n + 3), (-1 : ℤ) ^ (l : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 l ρ τ) + (x (𝒰.strictDelete l ρ) τ) := by + rw [CofaceModule.differential] + simp only [ModuleCat.hom_sum, ModuleCat.hom_zsmul, ModuleCat.hom_ofHom, + LinearMap.sum_apply, Finset.sum_apply] + rfl + rw [hfirst] + change + (∑ j : Fin (n + 2), Aterm j) + + (if hi : owner τ ∈ 𝒰.strictSupport σ then 0 else + (-1 : ℤ) ^ (𝒰.strictInsertPosition σ (owner τ) hi : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert 𝒰 𝒱 q owner howner σ τ hi) + (((horizontalCofaceModule 𝒰 𝒱 q).differential (n + 1)).hom + x ρ τ)) = + x σ τ + rw [dif_neg hnot] + rw [hsecond] + rw [Fin.sum_univ_succAbove _ k, map_add, map_sum, + smul_add, Finset.smul_sum] + change (∑ j : Fin (n + 2), Aterm j) + + ((-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hnot) + ((-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 k ρ τ) + (x (𝒰.strictDelete k ρ) τ)) + + ∑ j : Fin (n + 2), Bterm j) = + x σ τ + rw [hidentity] + have hsum : + (∑ j : Fin (n + 2), Aterm j) + ∑ j : Fin (n + 2), Bterm j = 0 := by + rw [← Finset.sum_add_distrib] + simp only [hcancel, Finset.sum_const_zero] + calc + (∑ j : Fin (n + 2), Aterm j) + + (x σ τ + ∑ j : Fin (n + 2), Bterm j) = + x σ τ + + ((∑ j : Fin (n + 2), Aterm j) + ∑ j : Fin (n + 2), Bterm j) := by + abel + _ = x σ τ + 0 := congrArg (x σ τ + ·) hsum + _ = x σ τ := add_zero _ + +/-- The augmentation and the degree-zero differential satisfy the contracting identity. -/ +theorem horizontalContracting_degree_zero + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) + (x : DoubleCochains 𝒰 𝒱 0 q) + (σ : 𝒰.StrictTuple 0) (τ : 𝒱.StrictTuple q) : + horizontalAugmentation 𝒰 𝒱 q + (horizontalContractZero 𝒰 𝒱 q owner howner x) σ τ + + horizontalContract 𝒰 𝒱 q owner howner 0 + (((horizontalCofaceModule 𝒰 𝒱 q).differential 0).hom x) σ τ = + x σ τ := by + by_cases hmem : owner τ ∈ 𝒰.strictSupport σ + · have hrange := (𝒰.mem_strictSupport_iff σ (owner τ)).1 hmem + obtain ⟨j, hj⟩ := hrange + have hvalue : σ 0 = owner τ := by + simpa only [Fin.eq_zero j] using hj + have hsingleton : 𝒰.strictSingleton (owner τ) = σ := by + ext a + rw [𝒰.strictSingleton_apply, Fin.eq_zero a, hvalue] + have hcontract : + horizontalContract 𝒰 𝒱 q owner howner 0 + (((horizontalCofaceModule 𝒰 𝒱 q).differential 0).hom x) σ τ = + 0 := by + change + (if hi : owner τ ∈ 𝒰.strictSupport σ then 0 else + (-1 : ℤ) ^ + (𝒰.strictInsertPosition σ (owner τ) hi : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hi) _) = 0 + exact dif_pos hmem + rw [hcontract, add_zero] + exact restriction_roundtrip_of_strictTuple_eq 𝒰 + (𝒱.tupleInter q τ) (𝒱.tupleInter q τ) + (𝒰.strictSingleton (owner τ)) σ hsingleton + (verticalTuple_subset_horizontalSingleton + 𝒰 𝒱 q owner howner τ) + (P.inter_subset_right (𝒰.tupleInter 0 σ) (𝒱.tupleInter q τ)) + (fun θ ↦ x θ τ) + · let k := 𝒰.strictInsertPosition σ (owner τ) hmem + let ρ := 𝒰.strictInsert σ (owner τ) hmem + let l := k.succAbove (0 : Fin 1) + have hdelete : 𝒰.strictDelete k ρ = σ := + 𝒰.strictDelete_strictInsert σ (owner τ) hmem + have hidentity : + (-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hmem) + ((-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 k ρ τ) + (x (𝒰.strictDelete k ρ) τ)) = + x σ τ := by + rw [map_zsmul, ← mul_zsmul, ← pow_add, + (Even.add_self (k : ℕ)).neg_one_pow, one_zsmul] + exact restriction_roundtrip_of_strictTuple_eq 𝒰 + (𝒱.tupleInter q τ) + (P.inter (𝒰.tupleInter 1 ρ) (𝒱.tupleInter q τ)) + (𝒰.strictDelete k ρ) σ hdelete + (doubleInter_subset_horizontalDelete 𝒰 𝒱 k ρ τ) + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hmem) + (fun θ ↦ x θ τ) + have hsingletonDelete : + 𝒰.strictSingleton (owner τ) = 𝒰.strictDelete l ρ := by + ext a + rw [Fin.eq_zero a, 𝒰.strictSingleton_apply] + have hindex : l.succAbove (0 : Fin 1) = k := by + simpa only [Fin.eq_zero ((0 : Fin 1).predAbove k)] using + Fin.succAbove_succAbove_predAbove k (0 : Fin 1) + exact congrArg Fin.val (by + change owner τ = ρ (l.succAbove 0) + rw [hindex] + exact (𝒰.strictInsert_apply_position σ (owner τ) hmem).symm) + have hpath : + P.restriction + (P.inter_subset_right (𝒰.tupleInter 0 σ) (𝒱.tupleInter q τ)) + (P.restriction + (verticalTuple_subset_horizontalSingleton + 𝒰 𝒱 q owner howner τ) + (x (𝒰.strictSingleton (owner τ)) τ)) = + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hmem) + (P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 l ρ τ) + (x (𝒰.strictDelete l ρ) τ)) := by + exact restriction_paths_eq_of_strictTuple_eq 𝒰 + (𝒱.tupleInter q τ) + (𝒱.tupleInter q τ) + (P.inter (𝒰.tupleInter 1 ρ) (𝒱.tupleInter q τ)) + (P.inter (𝒰.tupleInter 0 σ) (𝒱.tupleInter q τ)) + (𝒰.strictSingleton (owner τ)) (𝒰.strictDelete l ρ) + hsingletonDelete + (verticalTuple_subset_horizontalSingleton + 𝒰 𝒱 q owner howner τ) + (P.inter_subset_right (𝒰.tupleInter 0 σ) (𝒱.tupleInter q τ)) + (doubleInter_subset_horizontalDelete 𝒰 𝒱 l ρ τ) + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hmem) + (fun θ ↦ x θ τ) + have hsign : + (-1 : ℤ) ^ ((k : ℕ) + (l : ℕ)) = -1 := by + have hcross := neg_one_pow_cross 0 k (0 : Fin 1) + simp only [Fin.val_zero, zero_add, + Fin.eq_zero ((0 : Fin 1).predAbove k), pow_zero] at hcross + dsimp only [l] + have hneg := congrArg Neg.neg hcross + simpa only [neg_neg] using hneg.symm + have hother : + (-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hmem) + ((-1 : ℤ) ^ (l : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 l ρ τ) + (x (𝒰.strictDelete l ρ) τ)) = + -P.restriction + (P.inter_subset_right (𝒰.tupleInter 0 σ) (𝒱.tupleInter q τ)) + (P.restriction + (verticalTuple_subset_horizontalSingleton + 𝒰 𝒱 q owner howner τ) + (x (𝒰.strictSingleton (owner τ)) τ)) := by + rw [map_zsmul, ← mul_zsmul, ← pow_add, hsign, neg_one_zsmul, + ← hpath] + have hdifferential : + ((horizontalCofaceModule 𝒰 𝒱 q).differential 0).hom x ρ τ = + ∑ a : Fin 2, (-1 : ℤ) ^ (a : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 a ρ τ) + (x (𝒰.strictDelete a ρ) τ) := by + rw [CofaceModule.differential] + simp only [ModuleCat.hom_sum, ModuleCat.hom_zsmul, ModuleCat.hom_ofHom, + LinearMap.sum_apply, Finset.sum_apply] + rfl + change + P.restriction + (P.inter_subset_right (𝒰.tupleInter 0 σ) (𝒱.tupleInter q τ)) + (P.restriction + (verticalTuple_subset_horizontalSingleton + 𝒰 𝒱 q owner howner τ) + (x (𝒰.strictSingleton (owner τ)) τ)) + + (if hi : owner τ ∈ 𝒰.strictSupport σ then 0 else + (-1 : ℤ) ^ (𝒰.strictInsertPosition σ (owner τ) hi : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hi) + (((horizontalCofaceModule 𝒰 𝒱 q).differential 0).hom x ρ τ)) = + x σ τ + rw [dif_neg hmem, hdifferential, Fin.sum_univ_succAbove _ k, + map_add, smul_add, Fin.sum_univ_one] + change + P.restriction + (P.inter_subset_right (𝒰.tupleInter 0 σ) (𝒱.tupleInter q τ)) + (P.restriction + (verticalTuple_subset_horizontalSingleton + 𝒰 𝒱 q owner howner τ) + (x (𝒰.strictSingleton (owner τ)) τ)) + + ((-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hmem) + ((-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 k ρ τ) + (x (𝒰.strictDelete k ρ) τ)) + + (-1 : ℤ) ^ (k : ℕ) • + P.restriction + (doubleInter_subset_horizontalInsert + 𝒰 𝒱 q owner howner σ τ hmem) + ((-1 : ℤ) ^ (l : ℕ) • + P.restriction + (doubleInter_subset_horizontalDelete 𝒰 𝒱 l ρ τ) + (x (𝒰.strictDelete l ρ) τ))) = + x σ τ + rw [hidentity, hother] + abel + +/-- The explicit contraction of a horizontal row whose vertical intersections have chosen +containing horizontal members. -/ +noncomputable def horizontalContractingHomotopy + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) : + (horizontalAugmentedCofaceModule 𝒰 𝒱 q).ContractingHomotopy where + h₀ := horizontalContractZero 𝒰 𝒱 q owner howner + h n := horizontalContract 𝒰 𝒱 q owner howner n + h₀_augmentation x := + horizontalContractZero_horizontalAugmentation + 𝒰 𝒱 q owner howner x + degree_zero x := by + funext σ τ + exact horizontalContracting_degree_zero + 𝒰 𝒱 q owner howner x σ τ + degree_succ n x := by + funext σ τ + by_cases hmem : owner τ ∈ 𝒰.strictSupport σ + · exact horizontalContracting_degree_succ_of_mem + 𝒰 𝒱 q owner howner n x σ τ hmem + · exact horizontalContracting_degree_succ_of_not_mem + 𝒰 𝒱 q owner howner n x σ τ hmem + +/-- A horizontal row with a chosen member containing every vertical tuple intersection is +acyclic. -/ +theorem horizontalAugmentedCofaceModule_acyclic_of_owner + (howner : ∀ τ : 𝒱.StrictTuple q, + P.subset (𝒱.tupleInter q τ) (𝒰.domain (owner τ))) : + (horizontalAugmentedCofaceModule 𝒰 𝒱 q).complex.Acyclic := + (horizontalContractingHomotopy 𝒰 𝒱 q owner howner).acyclic + +namespace Refinement + +variable {𝒰 𝒱 : P.Family} + +/-- A refinement supplies a containing coarse member for every strict tuple of the finer +family, by using its first entry. -/ +noncomputable def tupleOwner (r : Refinement 𝒱 𝒰) (q : ℕ) : + 𝒱.StrictTuple q → Fin 𝒰.card := + fun τ ↦ r.index (τ 0) + +theorem tupleInter_subset_tupleOwner (r : Refinement 𝒱 𝒰) (q : ℕ) + (τ : 𝒱.StrictTuple q) : + P.subset (𝒱.tupleInter q τ) (𝒰.domain (r.tupleOwner q τ)) := + P.subset_trans (𝒱.tupleInter_subset_domain q τ 0) (r.subset (τ 0)) + +/-- Every horizontal restricted row associated with a refinement is contractible. -/ +theorem horizontalAugmentedCofaceModule_acyclic + (r : Refinement 𝒱 𝒰) (q : ℕ) : + (horizontalAugmentedCofaceModule 𝒰 𝒱 q).complex.Acyclic := + horizontalAugmentedCofaceModule_acyclic_of_owner + 𝒰 𝒱 q (r.tupleOwner q) (r.tupleInter_subset_tupleOwner q) + +/-- If the horizontal family refines the vertical family, every vertical restricted column is +contractible. -/ +theorem verticalAugmentedCofaceModule_acyclic + (r : Refinement 𝒰 𝒱) (p : ℕ) : + (verticalAugmentedCofaceModule 𝒰 𝒱 p).complex.Acyclic := by + have hhorizontal : + (horizontalAugmentedCofaceModule 𝒱 𝒰 p).complex.Acyclic := + r.horizontalAugmentedCofaceModule_acyclic p + intro n + exact (hhorizontal n).of_iso + (verticalAugmentedCofaceModuleIso 𝒰 𝒱 p).symm + +end Refinement + +end Presheaf.Family + +end Rigid.Cech diff --git a/Rigid/Cech/StrictTuple.lean b/Rigid/Cech/StrictTuple.lean new file mode 100644 index 0000000..b67e76e --- /dev/null +++ b/Rigid/Cech/StrictTuple.lean @@ -0,0 +1,349 @@ +import Mathlib.Order.Hom.PowersetCard +import Rigid.Cech.Normalized + +set_option linter.style.header false + +/-! +# Inserting an index into a normalized Čech tuple + +Normalized Čech cochains are indexed by increasing tuples. The contracting homotopy for a +family with a distinguished member inserts that member into a tuple, unless it is already +present. This file isolates the finite-order bookkeeping for that operation. +-/ + +universe u v w + +namespace Rigid.Cech + +variable {R : Type u} [Ring R] +variable {P : Presheaf.{u, v, w} R} + +namespace Presheaf.Family + +variable (𝒰 : P.Family) + +/-- The unique increasing one-term tuple with prescribed value. -/ +noncomputable def strictSingleton (i : Fin 𝒰.card) : 𝒰.StrictTuple 0 := + ({i} : Finset (Fin 𝒰.card)).orderEmbOfFin (by simp) + +@[simp] +theorem strictSingleton_apply (i : Fin 𝒰.card) (j : Fin 1) : + 𝒰.strictSingleton i j = i := by + unfold strictSingleton + exact Finset.orderEmbOfFin_singleton i j + +/-- Every one-term strict tuple is the canonical singleton determined by its value. -/ +theorem strictTuple_zero_eq_singleton (σ : 𝒰.StrictTuple 0) : + σ = 𝒰.strictSingleton (σ 0) := by + ext j + rw [Fin.eq_zero j, strictSingleton_apply] + +/-- The finite set underlying a strictly increasing Čech tuple. -/ +noncomputable def strictSupport {n : ℕ} (σ : 𝒰.StrictTuple n) : + Finset (Fin 𝒰.card) := + Finset.univ.image σ + +@[simp] +theorem mem_strictSupport_iff {n : ℕ} (σ : 𝒰.StrictTuple n) (i : Fin 𝒰.card) : + i ∈ 𝒰.strictSupport σ ↔ i ∈ Set.range σ := by + simp [strictSupport] + +@[simp] +theorem card_strictSupport {n : ℕ} (σ : 𝒰.StrictTuple n) : + (𝒰.strictSupport σ).card = n + 1 := by + simp [strictSupport, Finset.card_image_of_injective _ σ.injective] + +/-- The canonical increasing tuple obtained by inserting a new index. -/ +noncomputable def strictInsert {n : ℕ} (σ : 𝒰.StrictTuple n) + (i : Fin 𝒰.card) (hi : i ∉ 𝒰.strictSupport σ) : + 𝒰.StrictTuple (n + 1) := + (insert i (𝒰.strictSupport σ)).orderEmbOfFin (by + rw [Finset.card_insert_of_notMem hi, card_strictSupport]) + +/-- The position occupied by the newly inserted index. -/ +noncomputable def strictInsertPosition {n : ℕ} (σ : 𝒰.StrictTuple n) + (i : Fin 𝒰.card) (hi : i ∉ 𝒰.strictSupport σ) : + Fin (n + 2) := + let hcard : (insert i (𝒰.strictSupport σ)).card = n + 2 := by + rw [Finset.card_insert_of_notMem hi, card_strictSupport] + ((insert i (𝒰.strictSupport σ)).orderIsoOfFin hcard).symm + ⟨i, Finset.mem_insert_self i _⟩ + +@[simp] +theorem strictInsert_apply_position {n : ℕ} (σ : 𝒰.StrictTuple n) + (i : Fin 𝒰.card) (hi : i ∉ 𝒰.strictSupport σ) : + 𝒰.strictInsert σ i hi (𝒰.strictInsertPosition σ i hi) = i := by + unfold strictInsert strictInsertPosition + exact congrArg Subtype.val + ((insert i (𝒰.strictSupport σ)).orderIsoOfFin _ |>.apply_symm_apply + ⟨i, Finset.mem_insert_self i _⟩) + +private theorem strictTuple_eq_orderEmbOfSupport {n : ℕ} (σ : 𝒰.StrictTuple n) : + σ = (𝒰.strictSupport σ).orderEmbOfFin (𝒰.card_strictSupport σ) := by + apply Finset.orderEmbOfFin_unique' + intro j + exact (𝒰.mem_strictSupport_iff σ (σ j)).2 ⟨j, rfl⟩ + +/-- Deleting the newly inserted position recovers the original tuple. -/ +@[simp] +theorem strictDelete_strictInsert {n : ℕ} (σ : 𝒰.StrictTuple n) + (i : Fin 𝒰.card) (hi : i ∉ 𝒰.strictSupport σ) : + 𝒰.strictDelete (𝒰.strictInsertPosition σ i hi) (𝒰.strictInsert σ i hi) = σ := by + let ρ := 𝒰.strictInsert σ i hi + let k := 𝒰.strictInsertPosition σ i hi + have hdel : + 𝒰.strictDelete k ρ = + (𝒰.strictSupport σ).orderEmbOfFin (𝒰.card_strictSupport σ) := by + apply Finset.orderEmbOfFin_unique' + intro j + have hmem : + ρ (k.succAbove j) ∈ insert i (𝒰.strictSupport σ) := by + exact Finset.orderEmbOfFin_mem _ _ _ + have hne : ρ (k.succAbove j) ≠ i := by + intro heq + have hki : ρ k = i := by + exact strictInsert_apply_position 𝒰 σ i hi + have hindex : k.succAbove j = k := + ρ.injective (heq.trans hki.symm) + exact (Fin.succAbove_ne k j) hindex + change ρ (k.succAbove j) ∈ 𝒰.strictSupport σ + simpa [hne] using hmem + exact hdel.trans (strictTuple_eq_orderEmbOfSupport 𝒰 σ).symm + +/-- The canonical insertion is `Fin.insertNth` at its canonical position. -/ +theorem strictInsert_coe {n : ℕ} (σ : 𝒰.StrictTuple n) + (i : Fin 𝒰.card) (hi : i ∉ 𝒰.strictSupport σ) : + (𝒰.strictInsert σ i hi : Fin (n + 2) → Fin 𝒰.card) = + Fin.insertNth (𝒰.strictInsertPosition σ i hi) i σ := by + apply Fin.eq_insertNth_iff.2 + constructor + · exact 𝒰.strictInsert_apply_position σ i hi + · funext j + have h := congrArg + (fun ρ : 𝒰.StrictTuple n ↦ ρ j) + (𝒰.strictDelete_strictInsert σ i hi) + simpa only [Fin.removeNth_apply, strictDelete, OrderEmbedding.coe_comp, + Function.comp_apply, Fin.succAboveOrderEmb_apply] using h + +/-- Deleting one entry removes its value from the support. -/ +theorem not_mem_strictSupport_strictDelete {n : ℕ} (ρ : 𝒰.StrictTuple (n + 1)) + (k : Fin (n + 2)) : + ρ k ∉ 𝒰.strictSupport (𝒰.strictDelete k ρ) := by + rw [𝒰.mem_strictSupport_iff] + rintro ⟨j, hj⟩ + have hindex : k.succAbove j = k := ρ.injective hj + exact (Fin.succAbove_ne k j) hindex + +/-- A value absent from a tuple remains absent after deleting an entry. -/ +theorem not_mem_strictSupport_strictDelete_of_not_mem {n : ℕ} + (ρ : 𝒰.StrictTuple (n + 1)) (i : Fin 𝒰.card) + (hi : i ∉ 𝒰.strictSupport ρ) (k : Fin (n + 2)) : + i ∉ 𝒰.strictSupport (𝒰.strictDelete k ρ) := by + intro hmem + rw [𝒰.mem_strictSupport_iff] at hmem + obtain ⟨j, hj⟩ := hmem + apply hi + rw [𝒰.mem_strictSupport_iff] + exact ⟨k.succAbove j, hj⟩ + +/-- Deleting an entry and canonically reinserting its value recovers the tuple. -/ +@[simp] +theorem strictInsert_strictDelete {n : ℕ} (ρ : 𝒰.StrictTuple (n + 1)) + (k : Fin (n + 2)) : + 𝒰.strictInsert (𝒰.strictDelete k ρ) (ρ k) + (𝒰.not_mem_strictSupport_strictDelete ρ k) = ρ := by + let hcard : + (insert (ρ k) (𝒰.strictSupport (𝒰.strictDelete k ρ))).card = n + 2 := by + rw [Finset.card_insert_of_notMem + (𝒰.not_mem_strictSupport_strictDelete ρ k), 𝒰.card_strictSupport] + calc + 𝒰.strictInsert (𝒰.strictDelete k ρ) (ρ k) + (𝒰.not_mem_strictSupport_strictDelete ρ k) = + (𝒰.strictSupport ρ).orderEmbOfFin (𝒰.card_strictSupport ρ) := by + change + (insert (ρ k) (𝒰.strictSupport (𝒰.strictDelete k ρ))).orderEmbOfFin hcard = + (𝒰.strictSupport ρ).orderEmbOfFin (𝒰.card_strictSupport ρ) + apply Finset.orderEmbOfFin_unique' + intro j + have hj : + (insert (ρ k) (𝒰.strictSupport (𝒰.strictDelete k ρ))).orderEmbOfFin + hcard j ∈ + insert (ρ k) (𝒰.strictSupport (𝒰.strictDelete k ρ)) := + Finset.orderEmbOfFin_mem + (insert (ρ k) (𝒰.strictSupport (𝒰.strictDelete k ρ))) hcard j + rcases Finset.mem_insert.mp hj with hj | hj + · rw [hj] + exact (𝒰.mem_strictSupport_iff ρ (ρ k)).2 ⟨k, rfl⟩ + · rw [𝒰.mem_strictSupport_iff] at hj ⊢ + obtain ⟨l, hl⟩ := hj + exact ⟨k.succAbove l, hl⟩ + _ = ρ := (strictTuple_eq_orderEmbOfSupport 𝒰 ρ).symm + +/-- The canonical position after deleting and reinserting an entry is the deleted position. -/ +@[simp] +theorem strictInsertPosition_strictDelete {n : ℕ} (ρ : 𝒰.StrictTuple (n + 1)) + (k : Fin (n + 2)) : + 𝒰.strictInsertPosition (𝒰.strictDelete k ρ) (ρ k) + (𝒰.not_mem_strictSupport_strictDelete ρ k) = k := by + have hrec := 𝒰.strictInsert_strictDelete ρ k + have happly := 𝒰.strictInsert_apply_position + (𝒰.strictDelete k ρ) (ρ k) + (𝒰.not_mem_strictSupport_strictDelete ρ k) + rw [hrec] at happly + apply ρ.injective + exact happly + +/-- Variant of `strictInsert_strictDelete` with the deleted value presented by an equal +external index. -/ +theorem strictInsert_strictDelete_of_eq {n : ℕ} (ρ : 𝒰.StrictTuple (n + 1)) + (k : Fin (n + 2)) (i : Fin 𝒰.card) + (hi : i ∉ 𝒰.strictSupport (𝒰.strictDelete k ρ)) (hki : ρ k = i) : + 𝒰.strictInsert (𝒰.strictDelete k ρ) i hi = ρ := by + let hcard : + (insert i (𝒰.strictSupport (𝒰.strictDelete k ρ))).card = n + 2 := by + rw [Finset.card_insert_of_notMem hi, 𝒰.card_strictSupport] + calc + 𝒰.strictInsert (𝒰.strictDelete k ρ) i hi = + (𝒰.strictSupport ρ).orderEmbOfFin (𝒰.card_strictSupport ρ) := by + change + (insert i (𝒰.strictSupport (𝒰.strictDelete k ρ))).orderEmbOfFin hcard = + (𝒰.strictSupport ρ).orderEmbOfFin (𝒰.card_strictSupport ρ) + apply Finset.orderEmbOfFin_unique' + intro j + have hj : + (insert i (𝒰.strictSupport (𝒰.strictDelete k ρ))).orderEmbOfFin hcard j ∈ + insert i (𝒰.strictSupport (𝒰.strictDelete k ρ)) := + Finset.orderEmbOfFin_mem _ _ _ + rcases Finset.mem_insert.mp hj with hj | hj + · rw [hj, ← hki] + exact (𝒰.mem_strictSupport_iff ρ (ρ k)).2 ⟨k, rfl⟩ + · rw [𝒰.mem_strictSupport_iff] at hj ⊢ + obtain ⟨l, hl⟩ := hj + exact ⟨k.succAbove l, hl⟩ + _ = ρ := (strictTuple_eq_orderEmbOfSupport 𝒰 ρ).symm + +/-- Variant of `strictInsertPosition_strictDelete` with an equal external index. -/ +theorem strictInsertPosition_strictDelete_of_eq {n : ℕ} + (ρ : 𝒰.StrictTuple (n + 1)) (k : Fin (n + 2)) (i : Fin 𝒰.card) + (hi : i ∉ 𝒰.strictSupport (𝒰.strictDelete k ρ)) (hki : ρ k = i) : + 𝒰.strictInsertPosition (𝒰.strictDelete k ρ) i hi = k := by + have hinsert := 𝒰.strictInsert_strictDelete_of_eq ρ k i hi hki + have happly := + 𝒰.strictInsert_apply_position (𝒰.strictDelete k ρ) i hi + apply ρ.injective + calc + ρ (𝒰.strictInsertPosition (𝒰.strictDelete k ρ) i hi) = + 𝒰.strictInsert (𝒰.strictDelete k ρ) i hi + (𝒰.strictInsertPosition (𝒰.strictDelete k ρ) i hi) := + congrArg + (fun θ : 𝒰.StrictTuple (n + 1) ↦ + θ (𝒰.strictInsertPosition (𝒰.strictDelete k ρ) i hi)) + hinsert.symm + _ = i := happly + _ = ρ k := hki.symm + +/-- Deleting a noninserted position from an inserted tuple is the same as first deleting the +corresponding old position and then inserting. -/ +theorem strictDelete_strictInsert_succAbove {n : ℕ} (σ : 𝒰.StrictTuple (n + 1)) + (i : Fin 𝒰.card) (hi : i ∉ 𝒰.strictSupport σ) (j : Fin (n + 2)) : + let ρ := 𝒰.strictInsert σ i hi + let k := 𝒰.strictInsertPosition σ i hi + let l := k.succAbove j + let τ := 𝒰.strictDelete l ρ + let m := j.predAbove k + 𝒰.strictDelete m τ = 𝒰.strictDelete j σ := by + dsimp only + ext a + simp only [strictDelete, OrderEmbedding.coe_comp, Function.comp_apply, + Fin.succAboveOrderEmb_apply] + rw [Fin.succAbove_succAbove_succAbove_predAbove] + have h := congrArg + (fun θ : 𝒰.StrictTuple (n + 1) ↦ θ (j.succAbove a)) + (𝒰.strictDelete_strictInsert σ i hi) + exact congrArg Fin.val (by + simpa only [strictDelete, OrderEmbedding.coe_comp, Function.comp_apply, + Fin.succAboveOrderEmb_apply] using h) + +/-- The inserted value occupies the predicted position after deleting a different position. -/ +theorem strictDelete_strictInsert_value {n : ℕ} (σ : 𝒰.StrictTuple (n + 1)) + (i : Fin 𝒰.card) (hi : i ∉ 𝒰.strictSupport σ) (j : Fin (n + 2)) : + let ρ := 𝒰.strictInsert σ i hi + let k := 𝒰.strictInsertPosition σ i hi + let l := k.succAbove j + let τ := 𝒰.strictDelete l ρ + τ (j.predAbove k) = i := by + dsimp only + simp only [strictDelete, OrderEmbedding.coe_comp, Function.comp_apply, + Fin.succAboveOrderEmb_apply] + rw [Fin.succAbove_succAbove_predAbove] + exact 𝒰.strictInsert_apply_position σ i hi + +/-- A noninserted deletion commutes with canonical insertion. -/ +theorem strictDelete_strictInsert_eq_insert {n : ℕ} (σ : 𝒰.StrictTuple (n + 1)) + (i : Fin 𝒰.card) (hi : i ∉ 𝒰.strictSupport σ) (j : Fin (n + 2)) : + let k := 𝒰.strictInsertPosition σ i hi + let hi' := 𝒰.not_mem_strictSupport_strictDelete_of_not_mem σ i hi j + 𝒰.strictDelete (k.succAbove j) (𝒰.strictInsert σ i hi) = + 𝒰.strictInsert (𝒰.strictDelete j σ) i hi' := by + dsimp only + let ρ := 𝒰.strictInsert σ i hi + let k := 𝒰.strictInsertPosition σ i hi + let l := k.succAbove j + let τ := 𝒰.strictDelete l ρ + let m := j.predAbove k + have hdelete : 𝒰.strictDelete m τ = 𝒰.strictDelete j σ := + 𝒰.strictDelete_strictInsert_succAbove σ i hi j + have hvalue : τ m = i := + 𝒰.strictDelete_strictInsert_value σ i hi j + let hi' := 𝒰.not_mem_strictSupport_strictDelete_of_not_mem σ i hi j + let hcard : + (insert i (𝒰.strictSupport (𝒰.strictDelete j σ))).card = n + 2 := by + rw [Finset.card_insert_of_notMem hi', 𝒰.card_strictSupport] + change τ = + (insert i (𝒰.strictSupport (𝒰.strictDelete j σ))).orderEmbOfFin hcard + apply Finset.orderEmbOfFin_unique' + intro a + refine Fin.succAboveCases m ?_ (fun b ↦ ?_) a + · rw [hvalue] + exact Finset.mem_insert_self _ _ + · have hb := congrArg (fun θ : 𝒰.StrictTuple n ↦ θ b) hdelete + rw [show τ (m.succAbove b) = 𝒰.strictDelete j σ b by + simpa only [strictDelete, OrderEmbedding.coe_comp, Function.comp_apply, + Fin.succAboveOrderEmb_apply] using hb] + exact Finset.mem_insert_of_mem + ((𝒰.mem_strictSupport_iff _ _).2 ⟨b, rfl⟩) + +/-- The insertion position after a noninserted deletion is obtained with `Fin.predAbove`. -/ +theorem strictInsertPosition_after_strictDelete {n : ℕ} (σ : 𝒰.StrictTuple (n + 1)) + (i : Fin 𝒰.card) (hi : i ∉ 𝒰.strictSupport σ) (j : Fin (n + 2)) : + let k := 𝒰.strictInsertPosition σ i hi + let hi' := 𝒰.not_mem_strictSupport_strictDelete_of_not_mem σ i hi j + 𝒰.strictInsertPosition (𝒰.strictDelete j σ) i hi' = j.predAbove k := by + dsimp only + let ρ := 𝒰.strictInsert σ i hi + let k := 𝒰.strictInsertPosition σ i hi + let l := k.succAbove j + let τ := 𝒰.strictDelete l ρ + let m := j.predAbove k + have hvalue : τ m = i := + 𝒰.strictDelete_strictInsert_value σ i hi j + let hi' := 𝒰.not_mem_strictSupport_strictDelete_of_not_mem σ i hi j + have heq : τ = 𝒰.strictInsert (𝒰.strictDelete j σ) i hi' := + 𝒰.strictDelete_strictInsert_eq_insert σ i hi j + have happly := + 𝒰.strictInsert_apply_position (𝒰.strictDelete j σ) i hi' + apply τ.injective + calc + τ (𝒰.strictInsertPosition (𝒰.strictDelete j σ) i hi') = + 𝒰.strictInsert (𝒰.strictDelete j σ) i hi' + (𝒰.strictInsertPosition (𝒰.strictDelete j σ) i hi') := + congrArg + (fun θ : 𝒰.StrictTuple (n + 1) ↦ + θ (𝒰.strictInsertPosition (𝒰.strictDelete j σ) i hi')) + heq + _ = i := happly + _ = τ m := hvalue.symm + +end Presheaf.Family + +end Rigid.Cech diff --git a/Rigid/Challenge.lean b/Rigid/Challenge.lean index 574bd10..d721445 100644 --- a/Rigid/Challenge.lean +++ b/Rigid/Challenge.lean @@ -1009,7 +1009,7 @@ theorem existsUnique_glue (hA : IsAffinoidAlgebra K A) /-- The augmented Čech complex of the rational-localization presheaf for a finite rational cover. -/ noncomputable def augmentedCechComplex (hA : IsAffinoidAlgebra K A) {U : AffinoidRationalSubdomain K A} - (𝒰 : Cover K A U) : CochainComplex (ModuleCat K) ℕ := sorry + (𝒰 : Cover K A U) : CochainComplex (ModuleCat.{v} K) ℕ := sorry /-- Degree zero of the augmented Čech complex is the ring of functions on the covered domain. -/ noncomputable def augmentedCechComplexDegreeZeroIso (hA : IsAffinoidAlgebra K A) diff --git a/Rigid/Development.lean b/Rigid/Development.lean index 5cece2a..2791756 100644 --- a/Rigid/Development.lean +++ b/Rigid/Development.lean @@ -9,7 +9,9 @@ import Rigid.Berkovich.RelativeNonempty import Rigid.Berkovich.CompletedResidue import Rigid.Berkovich.RationalLocalization import Rigid.Berkovich.AffinoidDomain +import Rigid.Cech.Normalized import Rigid.AffinoidSpectrum.RationalBasis +import Rigid.AffinoidSpectrum.TateAcyclicity import Rigid.AffinoidAlgebra.QuotientNorm import Rigid.AffinoidAlgebra.QuotientTopology import Rigid.AffinoidAlgebra.RationalDatum @@ -1479,17 +1481,72 @@ theorem existsUnique_glue (hA : IsAffinoidAlgebra K A) /-- The augmented Čech complex of the rational-localization presheaf for a finite rational cover. -/ noncomputable def augmentedCechComplex (hA : IsAffinoidAlgebra K A) {U : AffinoidRationalSubdomain K A} - (𝒰 : Cover K A U) : CochainComplex (ModuleCat K) ℕ := sorry + (𝒰 : Cover K A U) : CochainComplex (ModuleCat.{v} K) ℕ := by + let hA' : Rigid.IsAffinoidAlgebra K A := by + obtain ⟨P⟩ := hA + exact ⟨{ n := P.n, ideal := P.ideal, equiv := P.equiv }⟩ + let toRigidDomain (V : AffinoidRationalSubdomain K A) : + Rigid.AffinoidRationalSubdomain K A := + { n := V.n, g := V.g, f := V.f, isRational := V.isRational } + let U' := toRigidDomain U + let 𝒰' : Rigid.AffinoidRationalSubdomain.Cover K A U' := + { m := 𝒰.m + domain := fun i ↦ toRigidDomain (𝒰.domain i) + subset := by + intro i x hx + let x' : BerkovichSpectrumOver K A := + { toBerkovichSpectrum := + { seminorm := x.toBerkovichSpectrum.seminorm + le_norm' := x.toBerkovichSpectrum.le_norm' } + map_algebraMap' := x.map_algebraMap' } + have hx' : x' ∈ (𝒰.domain i).carrier := by + intro j + exact hx j + have hU := 𝒰.subset i hx' + intro j + exact hU j + covers := by + ext x + let x' : BerkovichSpectrumOver K A := + { toBerkovichSpectrum := + { seminorm := x.toBerkovichSpectrum.seminorm + le_norm' := x.toBerkovichSpectrum.le_norm' } + map_algebraMap' := x.map_algebraMap' } + have hcover := Set.ext_iff.mp 𝒰.covers x' + constructor + · intro hx + have hx' : x' ∈ U.carrier := by + intro j + exact hx j + obtain ⟨i, hi⟩ := Set.mem_iUnion.mp (hcover.mp hx') + apply Set.mem_iUnion.mpr + refine ⟨i, ?_⟩ + intro j + exact hi j + · intro hx + obtain ⟨i, hi⟩ := Set.mem_iUnion.mp hx + have hi' : x' ∈ (𝒰.domain i).carrier := by + intro j + exact hi j + have hx' := hcover.mpr (Set.mem_iUnion.mpr ⟨i, hi'⟩) + intro j + exact hx' j } + exact 𝒰'.normalizedCechComplex K A hA' /-- Degree zero of the augmented Čech complex is the ring of functions on the covered domain. -/ noncomputable def augmentedCechComplexDegreeZeroIso (hA : IsAffinoidAlgebra K A) {U : AffinoidRationalSubdomain K A} (𝒰 : Cover K A U) : - (𝒰.augmentedCechComplex K A hA).X 0 ≅ ModuleCat.of K U.Sections := sorry + (𝒰.augmentedCechComplex K A hA).X 0 ≅ ModuleCat.of K U.Sections := by + change ModuleCat.of K U.Sections ≅ ModuleCat.of K U.Sections + exact Iso.refl _ /-- Tate acyclicity: the augmented Čech complex of every finite rational cover is exact. -/ theorem tateAcyclicity (hA : IsAffinoidAlgebra K A) {U : AffinoidRationalSubdomain K A} (𝒰 : Cover K A U) : - (𝒰.augmentedCechComplex K A hA).Acyclic := sorry + (𝒰.augmentedCechComplex K A hA).Acyclic := by + unfold augmentedCechComplex + dsimp only + apply Rigid.AffinoidRationalSubdomain.Cover.tateAcyclicity K A end Cover